Close the gaps between what Rust source contains and what the graph records

[zzet]

Why

Rust extraction looked complete — docs/languages.md rated it "Full" across the
board — but measuring it against real crate source told a different story. I ran
the extractor over 4,000 .rs files (68 MB, ~577 crates from the local Cargo
registry), counting tree-sitter node types present in the source against graph
nodes actually emitted.

Whole categories of declaration produced zero nodes:

construct	present in corpus	nodes emitted
macro_invocation (concealing call sites)	68,551	0
extern "C" blocks	38,973	0
type aliases	10,094	0
generic_function calls (xs.collect::<Vec<_>>())	5,301	0
mod	4,206	0
macro_rules!	1,148	0
extern crate / associated_type / union	416 / 225 / 162	0

Others were silently wrong, which is worse than missing — a confidently
incorrect edge is one nobody re-checks.

What changed

Eight commits, one per behaviour.

Coverage. Query patterns and emitters for mod (indexed as a package node,
following the C++/C# namespace precedent — KindModule is reserved for
package-manager dependencies), type aliases, unions and their fields,
macro_rules!, extern-block functions with their ABI, extern crate,
associated types, and tuple-struct / enum-variant payload fields.

Calls hidden in macros. Rust does not parse macro arguments as expressions —
every macro_invocation carries an opaque token tree — so any query over
call_expression is blind to calls written inside one. 42,511 of the corpus's
invocations are assert*!, meaning the call a #[test] actually exercises was
precisely the one never recorded. Recovered by a token scan over the three call
shapes Rust can spell, labelled Meta["via_macro"] so consumers wanting only
grammar-certain edges can filter. Pattern and cfg-predicate macros are excluded,
so matches!(x, Some(_)) does not report a call to Some.

Correctness fixes, each reproduced with a probe before being fixed:

• Two same-named types in one file collapsed into one node and the loser's
  fields were re-parented onto the survivor, which then reported members it
  does not have. Now routed through the existing disambiguateID helper, with
  scope_mod distinguishing them.
• Associated consts were emitted at file scope, so impl A { const LIMIT } and
  impl B { const LIMIT } fought over one id and the loser vanished entirely.
• Type canonicalisation emitted targets that name no possible node —
  unresolved::"u8, u16" from Result<(u8, u16), E>, unresolved::"[Item]"
  from &[Item], unresolved::"Error + Send + 'static" from a boxed trait
  object. A tuple now expands to one edge per slot.
• impl Trait for &'a Buf minted the method id <file>::&'a Buf.show with a
  member_of edge to a node that never exists, orphaning the method.
• rustCollectAttributes stopped at the first non-attribute sibling, so a
  comment between an attribute stack and its item discarded every attribute
  above it.
• Result error extraction split on every comma and anchored on the last ::
  in the string, so Result<(u8, u16), E> emitted a throws edge to the literal
  "u16)" and std::result::Result<T, io::Error> emitted none at all.
• Trait members were reported private even when their trait was pub,
  understating the public API surface.
• signature was the hardcoded placeholder fn name(...) on every Rust
  function; async/unsafe/const/extern qualifiers were never recorded.

Relationships. Neither way a Rust type acquires a trait produced an
implements edge: impl Display for Buf emitted only a method-level
EdgeOverrides (so a marker impl left no trace at all) and #[derive(...)]
emitted only an annotation — despite derive being how most Rust types get
Debug, Clone and Serialize. Attributes on impl blocks were dropped
wholesale, which is why the file-level wasm_bindgen sentinel missed the form
the wasm-bindgen guide recommends for methods.

Entry points. entrypoints.Detect had no rust case, so nothing in a Rust
repo was ever a live root and the dead-code analyzer reported every binary
crate's entire call tree as dead. Now stamps fn main in Cargo binary targets,
async-runtime mains, test/bench harnesses, and FFI exports; extern block
declarations are stamped rust:ffi-import because their body lives in another
language, so a missing definition is not a missing implementation.

Result

Re-measured over the same 4,000 files:

	before	after
call edges	238,457	381,608 (+60%)
total nodes	221,676	370,822 (+67%)
implements edges	0	35,604
typed_as edges	30,544	103,130
returns edges	21,325	51,819
annotated edges	54,545	99,778

go build ./... and go test -race ./... pass. 663 lines of new tests, each
asserting the specific defect it covers.

Deliberately not in this change

The audit also surfaced problems outside the parsing layer, listed here so they
are not lost. The resolver ones matter most because they produce confidently
wrong results rather than missing ones:

• use super::X from a non-mod.rs module file resolves one directory too high
  and binds to the wrong file at full ast_resolved confidence.
• Module-qualified path calls (alpha::helper()) bind to an unrelated module's
  same-named function.
• #[path = "..."] is ignored; glob re-exports (pub use inner::*) are dropped;
  group imports (use crate::{a, b}) never resolve.
• Cargo workspace siblings are misclassified as external dependencies, and
  [workspace.dependencies] is never parsed.
• Axum/actix attribute routes bind to the function preceding the attribute.
• No tokio channel-ops, sqlx SQL extraction, or ORM lane for diesel/sea-orm.

I also verified and rejected one reported issue: a field's doc comment bleeding
onto the next undocumented field does not reproduce.