Recover missing C function usages + faster LSP enrichment

[zzet]

Summary

Four independent fixes that recover C find_usages results clangd resolves but Gortex was silently missing (measured against clangd ground truth on redis), plus a cross-language enrichment-scheduling fix.

1. Pointer-return function definitions and prototypes are now extracted

The function-definition query only matched a bare function_declarator, so a pointer-return signature — robj *streamDup(), static inline list *f(), robj **g() — where tree-sitter nests the function_declarator under one or
two pointer_declarators, produced no node at all. Call sites inside such a function's body then had no enclosing function, so their call edges were dropped too.

The definition is now matched broadly and the name derived by peeling the declarator chain; the C prototype and C++ free-function queries gain pointer-declarator alternations, and C++ extractFuncName descends pointer/reference/parenthesized wrappers so pointer-return methods are no longer dropped.

2. Generated .def command tables are indexed and their references recovered

A generated C fragment such as redis's src/commands.def — thousands of MAKE_CMD(...) rows #included into a translation unit — was never parsed (.def had no extractor), so the only reference to a command function lived in an unindexed file and find_usages reported the function as unused and safe to remove.

.def is now parsed as C (an uncontested extension) and a clearly-C .inc fragment is content-routed to the C extractor without disturbing the PHP/Pascal/asm claimants. A bare function identifier used in a table value position (a macro/call argument, an aggregate initializer element, a designated .field initializer) is captured as a function-value reference attributed to the file node and bound by the resolver to the command function in its defining translation unit.

3. Cross-file function-address value references bind

A function used by address in another translation unit — a function-pointer identity check (c->cmd->proc != execCommand), a function-pointer assignment, a return of a function, or &fn — returned zero usages because same-file value capture drops any name the file does not declare, and C addresses functions across a flat extern namespace.

These in-function value positions are now captured and bound repo-globally, guarded so a file-local static function is never the target of a cross-module reference and a same-file definition wins over a same-named extern elsewhere.

4. LSP enrichment: parallel confirm pass + reserved add-phase budget

The reference-confirm pass ran sequentially — one open+references+close round trip per ambiguous edge (~7 edges/s) — under the full per-repo deadline, so on a medium repo it consumed the whole window before the hover / hierarchy add phase ran even once. edges_added stayed 0 and the lsp-tier answer set was a strict subset of an already-sparse graph. This reproduced across clangd, gopls, and rust-analyzer, so it is not a C quirk.

The reference sweep now fans out across maxParallel, grouped by referent file so each file is opened once and serves every target sharing it, ordered highest-yield-first so a deadline cut leaves the most confirmations landed. A
fraction of the per-repo deadline is reserved for the post-confirm sweep so a slow confirm pass can no longer starve it. The definition-rebind fallback (which opens arbitrary call-site files) runs serially after the parallel sweep so document open/close never overlaps across goroutines.

5. LSP enrichment reliability

Making enrichment faster and more concurrent amplifies crash storms and wasted work, so this PR also lands three adjacent reliability fixes for the same code path:

• clangd enrichment can trigger clang-tidy crashes and high CPU #220 — clang-tidy crashes / high CPU: clangd now runs with --clang-tidy=false. Gortex consumes semantic graph signal, not lint diagnostics, and a broad repo .clang-tidy could crash clangd into a crash → reconnect → reindex loop that pinned it at high CPU for the whole pass (observed ~113-minute runs). --background-index is kept — the reference-confirm pass depends on it for cross-file results. Closes clangd enrichment can trigger clang-tidy crashes and high CPU #220
• LSP enrichment sends non-C/C++ files to clangd #221 — non-C/C++ files sent to clangd: enrichment never opens a file whose extension is outside the provider's ServerSpec coverage. A servesFile guard is applied at every document-open site (implementation pass, confirm grouping, hover / hierarchy sweep, definition rebind fallback), so an asset (.png / .svg) or unrelated script (.sh) is no longer opened on clangd only to churn on an invalid AST. Closes LSP enrichment sends non-C/C++ files to clangd #221
• Add crash-loop guard for LSP semantic enrichment #222 — crash-loop guard: a per-pass cap on reconnect cycles. reconnectWithBackoff already caps connection retries within one cycle; this caps the number of cycles, so a server that connects cleanly but keeps exiting mid-request is abandoned for the repo after the cap — with everything already flushed left intact and the provider / repo / reconnect count logged — instead of reconnecting without bound. A transient one-off exit still reconnects. Closes Add crash-loop guard for LSP semantic enrichment #222

Testing

• New unit / end-to-end tests for each change: pointer-return extraction, command-table + designated-initializer binding, cross-file / static-guard binding, .def / .inc detection, the parallel-confirm reserved-budget path, the provider-coverage guard (asset files never reach clangd), and the crash-loop guard (a repeatedly-crashing server is abandoned, not looped).
• go test ./... green — the only failures were two wall-clock perf tests that are load-flaky under full-suite contention and pass in isolation.
• Touched packages pass under -race; the concurrent enrichment path is validated under -race and non-flaky.
• golangci-lint clean; wire-contract fingerprint unchanged (no graph node/edge schema changes).

Notes

No changes to graph node/edge schemas. The end-to-end index benchmark on redis (and the Go regression benchmark) is the recommended pre-merge validation.