fix(test-impact): a parse gap names only reached functions, variables, macros - #2970

What this changes

The test-impact engine reads the text of a parse gap (lines the C parser could
not turn into edges): when the text names a definition the walk reached, the
definition around the gap is reached too. Two parts of that rule made it fire
almost everywhere in this repository:

• a gap's words were matched against the short name of every reached
  node, fields and types included, so words like idx, n, index and
  used fired gaps in unrelated code;
• a gap outside every definition seeded its whole file.

The cascade reaches code the change cannot reach. One file-scope gap shows
the mechanism: src/foundation/compat_thread.c:109
(__attribute__((used))) fired on any reached field named used and seeded
the whole file, including cbm_mutex_init, which the memory core calls, so
the walk went on to every caller of cbm_free. In the replays below the
old rule kept 79-81% of the 10,302 mapped tests for every product change, and in
the setup without a team artifact it vetoed whole runs (RUNNER_REACHED
through the memory core).

User decision R155 (2026-11-11):

• a gap's words match only the names of reached functions, methods,
  variables and macros of at least three characters;
• a gap outside every definition seeds the definitions that start on its
  own lines, never its whole file.

A gap inside a function that names a reached function still reaches that
function's callers, as before.

Replays

Setup: one base for every replay, b3ec08d (main on 2026-11-12), with its
producer bundle (graph + Linux x86_64 coverage map, 0.1 days old, admitted).
Each change is the revert of a recently merged PR on top of b3ec08d
(git merge-tree + commit-tree, no refs): a revert touches the same
functions as the PR, so it reaches the same code, and every replay can share
one admissible coverage map. 13 of 16 candidates revert cleanly (0d835c5,
5b87320 and f61d7c0 conflict with later commits). Old = the engine on
main (c90b1d9); new = this branch. Tests are counted at test level: a whole
suite counts all its mapped tests.

Of 10,302 mapped tests, the old engine kept 79-81% for every product change;
the new one keeps 44-45% for small changes and 74-75% for the two
pipeline-wide ones (the test-only change is the same either way).
With a bundle the old engine did not veto in this set; it over-selected: a
watcher change, for example, pulled in every language-server, grammar and
cypher suite.

The four PRs replayed for #2959 (merged PR as M^1..M, no bundle, so
every suite runs whole and only the run-all reason matters):

The remaining veto on 0d835c5 and 5b87320 does not come from a gap: a
debug run of 5b87320 shows no gap seeding cbm_kind_in_set_free_cache
(both PRs edit internal/cbm/cbm.h; the seed comes from the change itself).
It is outside this change and recorded for a follow-up.

Miss audit

The oracle is independent of the engine's walk: the producer bundle of the
base commit b3ec08d (its graph and its per-test coverage map, recorded on
Linux x86_64, 10,302 tests). For each replay it collects the tests the change
really needs:

• every test whose recorded coverage executes a changed function;
• every test of a suite whose setup (suite:*) executes one;
• for a changed definition that is not a mapped function (a macro, a global,
  a type, a field, a function no test executed): every test executing a
  function that uses it: by graph edge (up to 6 hops to the nearest mapped
  caller), by name in its source text (macros, globals, types), or by member
  access ->name / .name (fields).

A test the new selection drops is a miss if the oracle needs it.

Result: no miss this change introduces. 9 replays, 22,551 dropped tests in
total; the oracle requires none of them (no dropped test executes a changed
function, a suite setup that does, or a user of a changed macro, global,
type or field).

• * 8bf489e: 4 tests are flagged for both engines, only through the
  oracle's coarse type rule. The change removes the field
  CBMDefinition.client_route_path. Every use of that field is in a function
  the change itself edits, and those tests are selected. The 4 tests only use
  CBMDefinition elsewhere, so they cannot see the removed field.
• 6df7fcb: the one product change the map cannot vouch for is
  src/main.c:print_help (the product binary, not the coverage runner). The
  tests that check the help text (suites cli, daemon_bootstrap) run whole
  in the new selection.
• 0640103 (a test-only change) selects the same 2,400 tests with both
  engines.

Four more clean reverts (edfb824, d40ebf6, ff812bf, 14aeda1) were
stopped without an answer after 21-27 minutes (main's engine) and 6-14
minutes (this branch), to keep the replay disk bounded: both engines sat in
the snapshot build, before any gap matching (cbm_pipeline_pass_calls on
the 35k-line tests/test_pipeline.c or the 22k-line tests/test_cli.c, or a
full rebuild after a Python change). That is a separate, pre-existing cost
(the same would run into select-tests' 30-minute budget in CI), recorded for
a follow-up. edfb824 is covered by the no-bundle replay above.

What the narrower rule gives up (accepted by R155)

• A gap that hides a use of a field or a type no longer reaches its
  enclosing definition. A changed field still reaches every reader the parser
  did see (USAGE edges) and every test whose coverage executes them.
• A gap that hides a call to a definition named with fewer than three
  characters no longer fires. In this repository that is the function
  sw (iris_export_xml.c) and the macros Q, U, I, S, CH and c.
• A gap outside every definition reaches only the definitions that start
  on its lines. 217 of the 585 C-family gap ranges in the graph lie outside
  every definition (44 files); before, each of them could seed its whole
  file.

CI scope

• What changes in CI: only how much of the test suite PR CI selects. No
  workflow, job, runner or gate changes. Less over-reach means fewer suites
  and tests on the test legs (x86 runs the selection, arm64/macOS/Windows its
  portable view, per fix(test-impact): started roles, fork PRs, base tooling, all test legs #2959).
• When it takes effect: select-tests runs the merge base's engine
  (fix(test-impact): started roles, fork PRs, base tooling, all test legs #2959), so this lands for PRs whose merge base contains it. This PR's own
  run uses main's engine, and a change to src/mcp/test_impact* runs
  everything by rule anyway.
• Gating: unchanged. select-tests stays outside ci-ok; the test legs
  gate as before, on what they are given to run.
• Risk: a test that is no longer selected because a gap stops firing.
  The miss audit above checks every dropped test against the recorded
  coverage of the changed code.
• Cost: no new jobs, no new steps.
• Off switches: unchanged (TEST_IMPACT_MODE=shadow, or the 'gate'
  default in pr.yml); reverting this commit restores the old matching.

Proof

• test_impact_engine_parse_gaps_name_only_reached_functions: on main's
  engine it fails with all three over-reaches (the file-scope gap's file, the
  field word used, the two-letter global nn); with this change it passes.
• test_impact_engine_parse_gaps_reach_what_they_name (a gap naming a
  reached function inside a function still selects its callers' tests)
  passes before and after.
• ASan + UBSan, macOS arm64: test_impact_engine 23/23; test_impact,
  test_impact_artifact, test_impact_runner_filter, runner_isolation 99/99.
• scripts/test.sh --contracts-only (every contract step, including
  tests/test_test_impact_selection.sh and tests/test_lane_wiring_contract.sh)
  passes; memory-core linter passes; clang-format (Homebrew LLVM) clean on the
  touched hunks. cppcheck 2.20 is left to the hosted lint job.