[Rigidity]

Adds 21 lints. Each one has a fixture in tests/warnings/ that includes cases it shouldn't report.

Lint	Default	Reports
self_comparison	warn	x == x, x < x, x - x, x ^ x, x & x and similar
identical_branches	warn	if expressions whose branches are the same
duplicate_condition	warn	Repeated conditions in an else if chain, and repeated operands of &&, ||, &, | on booleans
bool_comparison	warn	x == true, x != false and so on
needless_bool	warn	if c { true } else { false }
negated_condition	allow	if !c { a } else { b } and if a != b { .. } else { .. }
collapsible_if	warn	else { if .. }, which can be else if
manual_assert	warn	if c { raise; }, which can be assert !c; (assert narrows the same way)
needless_let_return	warn	let x = expr; x at the end of a block
redundant_field_names	warn	Point { x: x }, in initializers and destructuring
unnecessary_parens	warn	Parentheses around atomic expressions, or around whole expressions such as conditions, let values and arguments
naming_convention	warn	Names that aren't snake_case (functions, modules, bindings), UpperCamelCase (structs, aliases, generics) or SCREAMING_SNAKE_CASE (constants)
shadowed_binding	allow	Bindings and parameters that shadow another one
debug_statement	allow	debug statements, meant to be turned on for release builds
unconditional_recursion	warn	Functions that call themselves on every path
redundant_inline	warn	inline const and inline let that are used once
large_inline	warn	Large inline fns whose body is duplicated at several call sites
repeated_expensive_call	warn	The same hash, coinid, BLS/secp call or function call evaluated again with the same arguments
bytes_int_confusion	warn	0xff as Int (which is -1) and 0x0001 as Int (not equal to 1)
unused_struct_field	warn	Fields that are never read (in the unused group)
unused_export	warn	exports of a mod that are only used inside of it (in the unused group)

Design notes

• Shared HIR equality (rue-lint/src/equality.rs). Code has no side effects other than raising, so two expressions written the same way are equal. Bindings are compared by value, so the same let in both branches counts as equal. Casts are ignored. self_comparison, identical_branches, duplicate_condition and repeated_expensive_call use it.
• redundant_inline only covers constants and bindings. I checked the compiler output: a non-inline const or let used once is already inlined, and the output is identical. A function used once is not inlined automatically, so inline fn used once isn't reported. A binding whose only use is in a lambda isn't reported either, since the lambda captures it.
• repeated_expensive_call only reports when the first call always runs before the second. The compiler doesn't reuse repeated results, so these calls cost twice. Calls in different branches of an if, or on the right side of &&/||, aren't reported, and neither are calls inside an already-reported call.
• unused_struct_field is conservative. A struct's value is also its layout, so its fields are only reported if every value of it is read by field. Values that are passed to a function taking that struct, bound with let, or used in if branches or block bodies don't count as escaping. Values that are hashed, returned, put into other values, cast or compared do, and so does any type guard against the struct. Structs that never have a value in the code (such as ones only used in an extern fn signature) are skipped.
• naming_convention also allows SCREAMING_SNAKE_CASE and Title_Snake_Case for parameters and fields. Chialisp's convention for curried arguments (and the structs that hold them) is uppercase. Truths are conventionally Title_Snake_Case, such as a Truth parameter and fields like Ephemeral_State. Let bindings must still be snake_case.
• large_inline thresholds: a body of at least 40 HIR nodes, with at least 200 nodes duplicated in total, counting each use after the first. These are rough guesses; a configurable threshold could come later.
• Infrastructure. HirLintPass gets a finish hook for passes that report after the walk. Passes are now built from the LintInput. The compiler records two new LintSites: struct field reads (destructured fields are only in the HIR through bindings the walk doesn't visit) and mod items (modules aren't declarations).
• Suggestions that are definitely safe are MachineApplicable. They drop to MaybeIncorrect when the code being replaced contains a comment.

Effect on existing code

• examples/puzzles/cat.rue: fixed the one new warning (tail_info: tail_info).
• Snapshot diagnostics changed in about 55 test YAML files. All of them are expected hits on the new lints. The largest groups are repeated_expensive_call, unused_struct_field and needless_let_return in test code.
• The existing lint unit tests and the LSP protocol test use let a = ..; a, which is now needless_let_return. I updated their expectations, or the source in the LSP test.

Testing

• cargo test --workspace --all-features, cargo clippy --workspace --all-features --all-targets, cargo fmt --check, and rue fmt --check all pass. The snapshot runner is stable.
• New unit tests apply every machine-applicable suggestion. They check that a combined style fixture and a removal fixture (debug, inline, export) both end up with no diagnostics.