feat(tauri): cross-language IPC bridge resolver (#772)

CHANGELOG.md

@@ -80,6 +80,7 @@ Full details in the entries below.
 - Parallel reference resolution now engages adaptively instead of by a fixed project-size cutoff: the indexer measures the actual per-reference resolution rate on the first batch and spins up the worker pool mid-run whenever the remaining work justifies it. Languages whose references are expensive to resolve benefit most — Rust especially: a fresh index of tokio runs about 23% faster, with the graph byte-for-byte identical. Small projects and low-core machines (2-core CI runners) keep the single-threaded path exactly as before.
 - The dynamic-dispatch analysis at the end of indexing now skips passes that provably can't produce anything for the project at hand: React re-render bridging when no class has a `render` method, React Native and Expo cross-platform pairing when the required languages aren't present, and MyBatis mapper linking when there's no mapper XML. Previously each of these scanned the whole graph before coming up empty — on a 4,000-file Java project that was about 0.9 seconds of wasted analysis per fresh index. The interface-implementation bridging pass also got cheaper on real work: it no longer re-fetches a hub interface's method list once per implementer, and classes that extend or implement nothing are skipped before any per-class lookups. Graphs remain byte-for-byte identical.
 - Indexing large C and C++ codebases spends much less time in the function-pointer dispatch analysis (the pass that connects handler tables like a command table or an ops struct to their call sites): each source file is now read and prepared once instead of four times, files that can't contribute any dispatch wiring are skipped outright in the later linking steps, and on platforms with the native engine the per-file scanning itself now runs natively too. On a Linux-kernel-scale tree the pass runs about a third faster end-to-end, with graphs byte-for-byte identical; platforms without a native binary keep the same results on the previous path.
+- **CodeGraph now traces Tauri's Rust ↔ JavaScript IPC boundary.** In a [Tauri](https://tauri.app) app the frontend reaches the Rust backend through a runtime IPC hop, so `callers` and `impact` on a `#[tauri::command]` function came back empty even when the entire frontend called it — the call crosses both a language boundary and a name change (the `tauri-specta` bindings turn `get_mcp_port` into `getMcpPort`). CodeGraph now bridges it: TypeScript / JavaScript / Svelte callers of `commands.fooBar()` (and raw `invoke('foo_bar')`) resolve to their Rust `#[tauri::command]` handler, and `events.fooBar.listen(...)` (and raw `listen('foo-bar')`) resolve to the Rust `#[derive(…Event)]` struct behind them, across the `snake_case` / `camelCase` / `PascalCase` / `kebab-case` conventions tauri-specta uses. It's picked up automatically from a `tauri.conf.json`, an `@tauri-apps/api` dependency, or any `#[tauri::command]` in the Rust sources (monorepo layouts included). Validated across three real apps: a `tauri-specta` app (Tauri 2 + Svelte 5) where 291 commands now surface their frontend callers, plus two raw-`invoke` apps where the string wire names resolve too (76 of 79 commands in one). (#772)
 
 ### Fixes