fix(registry): rank test-file definitions as test for production callers - #2968

What regressed

#2427 (merged as b3ec08d) ranks registry candidates by the extractor's stored
test verdict instead of the old QN substring scan. That verdict is incomplete
for everything but callables: the extractor ORs the file's test-ness into
functions, methods and the module only (internal/cbm/extract_defs.c), so a
variable, field, class, struct or interface defined in a test file keeps
is_test=false. The QN scan used to hide this, because Java and Scala QNs spell
src.test and test class names.

Since #2427 those symbols rank as production code. A name-only match
(suffix_match) from production code then picks them whenever they share more
of the caller's path than the real candidate. Examples on main:

• finagle: Future.exception(...) in production code binds to a Variable in
  TimeoutFactoryTest.scala.
• kafka: production Scala xs.map(...) binds to a Variable map in
  LogCleanerTest.scala; production->test-file CALLS onto Variables went from
  6 to 362.
• gardener: production calls bind to Go structs declared in _test.go files
  (75 of them).

Fix (two commits)

1. fix(registry): rank every definition in a test file as test. The three
   registry seeders (pass_definitions.c, pass_parallel.c,
   pipeline_incremental.c) already pass extractor verdict || cbm_registry_test_double_path(path). They now also OR in
   cbm_is_test_file, the exact rule the extractor computes is_test_file
   with, on the same path (the one the node stores) and the same language, so
   every definition in a test file ranks as test, identically in full and
   incremental indexes.

2. fix(registry): let test code rank test candidates like real code. The
   test penalty is for production callers. Test and test-double code uses its
   own helpers and mocks, so for such a caller no candidate takes the penalty
   and proximity alone ranks. The caller's verdict uses the same three rules
   (the extractor's verdict stored on the calling definition, the file rule,
   the test-double path rule) and reaches the registry from both call
   resolvers and both USAGE / READS / WRITES resolvers. Without this, kafka's
   clients tests calling new MockTime() bound TopologyTestDriver.MockTime
   in streams/test-utils/src/main instead of the clients test helper.

Scope is ranking only: the stored is_test property, TESTS-edge rules and
importance are unchanged (the test-file nodes still store is_test:false).

Tests

Three new pipeline tests beside #2427's rank probes, each run as a full index
(sequential), a fresh full index padded past MIN_FILES_FOR_PARALLEL with
CBM_WORKERS (parallel resolver), a comment-only edit on the closure-repair
route and one on the forced legacy-partial route:

• pipeline_registry_ranks_test_file_variable_last_full_and_incremental
  (Go: a package-level variable in app/sub/parse_test.go vs the production
  lib.Parse)
• pipeline_registry_ranks_test_file_class_last_full_and_incremental
  (Java multi-module layout: a class nested in streams/src/test/.../RunTest
  vs the production clients/.../Codec)
• pipeline_registry_test_caller_ranks_test_helpers_full_and_incremental
  (Java: a clients test's new MockTime() vs a same-named class in a
  test-utils/src/main module)

All three are RED on their base and GREEN with their commit. For the first
two, reverting only the pass_parallel.c hunk turns the parallel leg RED and
reverting only the pipeline_incremental.c hunk turns the closure-repair leg
RED; for the third, ignoring the caller's verdict in the scorer turns it RED,
and so does dropping it at the parallel call site alone.

Proof

Production-source edges whose target is in a test file (cbm_is_test_file on
both ends). Columns: before #2427 (cf337a6) / main (b3ec08d) / this PR.

finagle with the Scala import work of #2360 (583e71b) on top: production->test
CALLS 566 -> 300, onto Variables 391 -> 107, onto Classes 4 -> 1.

• fix(registry): score a candidate on the extractor's test verdict, not its name #2427's gains survive: every production edge fix(registry): score a candidate on the extractor's test verdict, not its name #2427 moved from a test file to
  production stays on production (gardener USAGE 125, WRITES 51, CALLS 1;
  kafka CALLS 59, USAGE 45, WRITES 13; finagle USAGE 17, CALLS 7).
• The second commit leaves every production-caller CALLS / USAGE / WRITES edge
  of kafka identical to the first commit, and gardener's production CALLS too.
• Test callers: kafka's new MockTime() calls bind the clients helper again
  (487 constructor and 17 class calls); gardener's mock packages bind their own
  symbols (USAGE into test-double files 4959 -> 5132, WRITES 61 -> 137).
  Test-caller CALLS that differ from main are mostly name-only member guesses
  either way (24 judged: 7 better, 6 worse, 10 wrong both ways, 1
  equivalent); kafka TESTS edges 64603 on main, 57518 here.
• Determinism: two runs of each corpus are edge-identical.
• Full vs incremental (25 seeded files, seed 168): finagle identical; gardener
  CALLS/USAGE/WRITES identical; kafka differs only for callers inside the
  edited files, exactly as main does.

Out of scope

• The stored is_test verdict and TESTS edges (unchanged by design).
• Name-only member-call guesses with an unknown receiver type (tp.topic()
  binding the project's one topic), which produce most of the remaining wrong
  edges in either direction. A receiver gate for them was measured and is not
  part of this PR.