feat: Rust language support (.rs)

[qoole]

Builds on #58 (PowerShell support), which builds on #40 (tree-sitter 0.25) — this branch is stacked on #58's branch, so ancestor commits appear here until those PRs merge; the Rust work is the ten commits from chore: add Rust tree-sitter grammar onward. Opening as a draft; I'll rebase and mark ready as the stack beneath it lands.

Tier-1 graph extraction for Rust via tree-sitter-rust 0.24.0 (the tree-sitter org's own grammar; prebuilds for all six platform/arch combos — #40's 0.25 runtime is the prerequisite, and the same npm overrides pattern handles its peer range).

What

• Definitions: functions, structs, enums, traits (→ interface), type aliases, unions, methods with impl-block owners (generics-stripped: impl Cache<T> owns as Cache), and macro_rules! definitions. Inline modules contribute scope segments (file.rs#imp.open), so cfg-gated sibling mods stay distinct and resolvable.
• Visibility: pub/pub(crate)/pub(super) → exported; pub(self) and plain items → not; trait-impl methods inherit the trait contract (exported); #[macro_export] macros exported; everything inside #[cfg(test)] mods unexported (#[cfg(not(test))] is correctly NOT matched).
• Calls: bare calls, method calls with typed-receiver inference (typed let, constructor-let T::new(), typed params, self → enclosing impl), Type::method / Self::method static calls, turbofish unwrapped, tuple-index calls guarded. Scoped calls (crate::worker::run()) resolve through the module tree and are restricted to the resolved file's candidates — never stripped to a bare name.
• Macros: invocations and definitions live in their own namespace — names carry the ! (log_it!), so a macro can never wire to a same-named function (Rust's namespaces are distinct). Std/prelude macros are skipped at extraction; path-qualified forms (std::println!) are recognized too.
• Imports: use paths (all forms: scoped, grouped per-leaf, renames, wildcards) and mod declarations resolve through the real module tree — crate::/super::/self::, both x.rs and x/mod.rs layouts, the parser-file rule (src/parser.rs's children live in src/parser/), inline-mod super consumption (a use super::* inside #[cfg(test)] mod tests correctly refers to its own file), and integration-test crate roots (tests/*.rs anchor crate:: to themselves, not the library).
• Workspaces: each Cargo.toml's [package] name (section-aware parse; [[bin]] names ignored) maps cross-crate imports (foo_bar::… ↔ crates/foo-bar/), including dependency { package = "…" } aliases; duplicate package names are treated as ambiguous and dropped rather than guessed, and crate matching is deterministic regardless of enumeration order.
• Domain isolation: Rust names resolve in a Rust-only domain — separate global-name and method-owner indexes — so a Rust symbol never links to a same-named symbol from another language, in either direction.
• Ambiguity posture: a type with several trait impls of the same method name (From<A>/From<B> both giving Frame.from; Display/Debug both giving fmt) drops the member call as ambiguous instead of guessing first-in-file. Drop-don't-guess throughout, matching map clusters one entry per file instead of per directory #35's resolution philosophy.

Evidence

• Suite: all green on this branch (77 Rust-specific assertions across extraction, bindings, resolution, and the review-derived regression pins below; plus CRLF, >32 KB, malformed-input tolerance, and double-build determinism guards mirroring the PowerShell suite).
• Real-world battery (two production Rust codebases, 350 files total, one a multi-crate polyglot workspace with a TS frontend): builds clean, byte-identical double-build determinism on both, 99.5% and 91.8% of internal-path imports wired (the remainder are dropped, never misdirected), 81 imports wired cross-crate through the workspace map, and zero cross-language edges in either direction in the polyglot repo.
• The branch went through two independent adversarial review passes before this PR; every wrong-edge finding became a failing-test-first fix (crate-root anchoring corner cases, inline-mod call paths, workspace crate-name shadowing of mod declarations, #[path] attributes, the cross-language method-owner leak). The reviews' dropped-edge findings are disclosed below rather than patched around.

Known limitations (deliberate; all fail toward dropped edges, never wrong ones)

• Macro token-tree bodies are opaque — assert_eq!(compute(), 3) contributes no compute call edge (no expansion).
• UFCS calls (<T as Tr>::method()) drop.
• #[path = "…"] mod declarations drop (resolving conventionally would wire the wrong file).
• Cross-file impl Trait for Type heritage is dropped (trait-default-method resolution needs the type defined in the same file).
• impl blocks inside function bodies mint unowned functions.
• Files nested deeper than one level under tests/ don't anchor crate:: (statically ambiguous — each test binary is its own crate).
• pub use re-export chains and proc-macro expansion are unsupported.
• Grammar 0.24.0 lacks Rust 1.82's &raw const/mut (~2–4% of files in modern codebases parse with errors; extraction degrades gracefully and still yields those files' other definitions). Happy to file that upstream.