[Rigidity]

Several compiler passes redid work for every binding or declaration in a chain, which made them quadratic or worse in its length and made a few tests much slower than they need to be. This removes that repeated work.

Changes

• Lowering (rue-hir/src/lower.rs)
  • Dependency sets are now cached per symbol, so they aren't recomputed every time a symbol is lowered.
  • group_symbols is now a topological layering in a single pass, instead of repeatedly scanning for symbols whose dependencies are ready.
  • lower_let_stmts now drains the leading statements at once rather than calling remove(0) in a loop.
• Recursion check (check_recursion.rs)
  • Cycles are found with one iterative Tarjan's SCC pass, instead of a separate search from each declaration.
  • A declaration that references a cycle without being part of it is still not reported. tests/symbols/invalid_recursion now covers that case.
  • One diagnostic changes: a declaration reached from a cycle more than once (const X = Y + Z; const Y = X; const Z = X;) is now reported once, where it used to be reported twice.
• Path resolution (compile/path.rs)
  • In the current scope, only the kind of name that the path expects is looked up. The other kind is looked up only if that fails.
• Symbol types (compiler.rs)
  • symbol_type_in walks the scope chain only for symbols whose type is overridden in some scope, which is tracked in push_mappings.
• Unused export lint (exports.rs)
  • The worklist in used_exports now shares one visited set across all exports, so types reached from one signature aren't walked again from the next.
• Tests
  • Added long_runs_of_bindings_are_grouped, which compiles 1000 chained bindings on the small stack (about 1.5s in debug).
  • Added tests/symbols/recursion_cycles: cycles of three or more, one cycle reaching another, mutually recursive inline functions, a constant that cycles through a function, and the deduplicated case above.
  • Added tests/symbols/symbol_and_type_names, which covers a type where a symbol is expected, a symbol where a type is expected, and a name that is both.

Timings

These are debug builds, compared against 65b2f24d. They were measured together with #295, but these tests only touch the code changed here:

Test	Before	After
chains_beyond_the_lowering_limit_are_an_error	12.1s	4.9s
deep_types_are_checked	10.2s	4.7s
long_chains_of_bindings_are_followed	6.5s	1.0s

With the debug CLI, a function containing 300 chained bindings went from 71s to 0.35s.

Not done here

• group_symbols is still quadratic in the worst case. DependencyGraph::dependencies returns transitive sets, so a chain of n bindings has about n²/2 edges. In a debug CLI, 1000 bindings of the form let x{i+1} = x{i} * x{i} + a; take about 35s, against more than 8 minutes on main. Making it linear would mean computing rounds from direct edges, carrying them through the symbols that aren't in the set (Grouping a long chain of bindings is still quadratic #296).
• This made a pre-existing debug-only stack overflow quick to reach (Long chains of single-use bindings overflow the stack in debug builds #293). That's left for a separate fix.