fix(parity): resolve C# same-class static bare calls in WASM and native (closes #1416)

Both WASM and native engines were missing call edges for bare static method
calls within the same C# class — e.g. `IsValidEmail()` inside
`Validators.ValidateUser` should resolve to `Validators.IsValidEmail`, but
neither engine had a same-class fallback for no-receiver calls.

Three-part fix:

1. WASM (`build-edges.ts`): after the `this.method()` same-class fallback,
   add a parallel fallback for no-receiver calls: when `targets` is empty
   and the call has no receiver, try `CallerClass.callName` in the same file.
   Only fires after the global exact lookup already failed, so module-level
   functions always win.

2. Native Rust (`edge_builder.rs`): mirror the WASM fallback in step 5
   of `resolve_call_targets` — when `call.receiver.is_none()` and the
   global exact lookup returns nothing, try `CallerClass.callName` scoped
   to the same file.

3. Role parity (`native-orchestrator.ts`): the Rust pipeline classifies
   roles before JS CHA/this-dispatch post-passes add edges, giving stale
   fan-out medians. When those post-passes insert new edges, run a full
   role re-classification so the final roles see the complete graph.

Result: C# same-file static recall improves from 0/2 (0%) to 2/2 (100%).
Build-parity test: 8/8 pass (nodes, edges, roles, ast_nodes identical).
docs check acknowledged

Author: carlos-alm

crates/codegraph-core/src/edge_builder.rs

@@ -503,6 +503,26 @@ fn resolve_call_targets<'a>(
             .unwrap_or_default();
         if !exact.is_empty() { return exact; }
 
+        // Bare-call same-class fallback: mirrors the WASM buildFileCallEdges same-class
+        // bare-call fallback. When a no-receiver call can't be resolved globally, try the
+        // caller's own class prefix: `IsValidEmail()` in `Validators.ValidateUser` →
+        // `Validators.IsValidEmail`. Safe: only fires after the global exact lookup fails,
+        // so module-level functions always take priority.
+        if call.receiver.is_none() {
+            if let Some(dot_pos) = caller_name.find('.') {
+                let class_prefix = &caller_name[..dot_pos];
+                let qualified = format!("{}.{}", class_prefix, call.name);
+                let class_scoped: Vec<&NodeInfo> = ctx.nodes_by_name
+                    .get(qualified.as_str())
+                    .map(|v| v.iter()
+                        .filter(|n| n.kind == "method" && n.file == rel_path)
+                        .copied()
+                        .collect())
+                    .unwrap_or_default();
+                if !class_scoped.is_empty() { return class_scoped; }
+            }
+        }
+
         // For this/self/super: prefer class-scoped exact lookup (e.g. `this.area()` in
         // `Shape.describe` → try `Shape.area` first).  This avoids false edges to unrelated
         // classes that happen to have a method with the same name in the same file.

src/domain/graph/builder/stages/build-edges.ts

@@ -1261,6 +1261,25 @@ function buildFileCallEdges(
       }
     }
 
+    // Same-class bare-call fallback: when a no-receiver call can't be resolved
+    // globally, try the caller's own class as a qualifier. Handles C# static
+    // sibling calls: `IsValidEmail()` inside `Validators.ValidateUser` resolves
+    // to `Validators.IsValidEmail`. Safe for JS/TS: only fires when byName()
+    // already returned nothing (so module-level functions are found first).
+    if (targets.length === 0 && !call.receiver && caller.callerName != null) {
+      const dotIdx = caller.callerName.indexOf('.');
+      if (dotIdx > 0) {
+        const className = caller.callerName.slice(0, dotIdx);
+        const qualifiedName = `${className}.${call.name}`;
+        const qualified = lookup
+          .byNameAndFile(qualifiedName, relPath)
+          .filter((n) => n.kind === 'method');
+        if (qualified.length > 0) {
+          targets = qualified;
+        }
+      }
+    }
+
     // Object.defineProperty accessor fallback: when a function is registered as
     // a getter/setter via `Object.defineProperty(obj, "bar", { get: getter })`,
     // calls to `this.X()` inside `getter` resolve against `obj` (this === obj

src/domain/graph/builder/stages/native-orchestrator.ts

@@ -1660,6 +1660,26 @@ export async function tryNativeOrchestrator(
     }
   }
 
+  // Full role re-classification after JS edge-writing post-passes.
+  // The Rust orchestrator classifies roles before these post-passes (CHA,
+  // this-dispatch) add edges, so the Rust-computed roles and the cached
+  // fan-out medians are stale. A full re-classification ensures the final
+  // roles reflect the true fan-in/out with all edges in place.
+  if (chaTargetIds.size > 0 || thisDispatchTargetIds.size > 0) {
+    try {
+      const { classifyNodeRoles } = (await import('../../../../features/structure.js')) as {
+        classifyNodeRoles: (
+          db: BetterSqlite3Database,
+          changedFiles?: string[] | null,
+        ) => Record<string, number>;
+      };
+      classifyNodeRoles(ctx.db as unknown as BetterSqlite3Database, null);
+      debug(`Post-pass full role re-classification complete`);
+    } catch (err) {
+      debug(`Post-pass full role re-classification failed: ${toErrorMessage(err)}`);
+    }
+  }
+
   // Backfill the `technique` column on `calls` edges written by the Rust
   // orchestrator, which does not write the column. Runs after all edge-writing
   // phases (including the WASM dropped-language backfill, CHA post-pass, and