perf(gfql): native chain seeds resolve through the resident indexes; named patterns served (#2027) - #2037

READY (9b190d2): 75/75 + RTD incl. tck-gfql; pins on both sides (policy off / stale index / IsIn+GT seeds → scan with parity); real-GPU: cuDF suites in the RAPIDS 26.02 image pass (stack tip run 958 passed; the 3 cuDF-26-only chain divergences are pre-existing on master and tracked in #2043/#2044). Stacked on #2035.

READY (4b91e9f) — restacked on master 9226829 after #2035 landed (patch-id identical to the previous head; base retargeted to master), plus one round-003 pin.

Round-003 amplification of the native seed lanes (owner ask: reflect on the review flow before this lands). A 51-shape × pandas/polars/cuDF differential probe (default route vs the native lanes forced to decline, plus the pandas full path as cross-engine oracle) was run at the #2038 head (which contains this PR) and at master: 140 parity / 3 both-raise (same exception class both routes) / 5 fixture errors that are identical on master / 3 cross-engine divergences that are identical on master. One stack-introduced divergence, pinned here:

• a node table with a repeated key row: the served native lookup answers one row per matching table row (the polars answer on both routes), while the pandas/cuDF full path self-joins the duplicates into 8 rows. The full-path blow-up predates this stack (master answers 8 on both routes because nothing is served); the new pin records both sides so a change to either is visible.

Pre-existing findings surfaced by the probe, not in this diff (for triage): gfql_index_all(engine="polars") on an edges-only graph raises AttributeError: 'DataFrame' object has no attribute 'get_column'; gfql_index_all(engine="cudf") raises cupy does not support object / category for string node keys and categorical props; polars resolves alias/column collisions with _right suffixes where pandas overwrites.

Cost receipt (local box, medians of 7, ms; [n({"id": k}, name="p")] and the seeded typed hop; indexed lanes flat in table size where master was linear, unindexed unchanged):

The one cost this PR adds is on the unindexed pandas seeded hop: about 0.6 ms at 10k rows for the gate that consults the resident indexes; it does not grow with table size.

Receipts at 4b91e9f

• Real GPU (dgx-spark, RAPIDS 26.02 image, 13 suites incl. test_chain.py): 1299 passed, 3 failed, 1 skipped (opt-in wall-clock gate), 2 xfailed. The 3 failures (test_chain.py:730 ×2, :1277) are identical on master in the same image (1257 passed / same 3): the cudf-26.02-only divergences tracked as gfql cuDF 26.02 (real GPU): chain default route and policy-forced full path disagree on prune_to_endpoints hops and duplicate node ids; tests use the removed cudf.DataFrame.from_pandas #2043, not this PR.
• CI: 77/77 check-runs success (incl. tck-gfql, changed-line coverage, polars-lane completeness, the three hygiene guards).
• pyg-bench sentinel native points (native-node-only, native-named-hop, native-hop-alias-collision) are this PR's lock-in; they were measured at the previous stack head and will be re-run on master once perf(gfql): native chain seeds resolve through the resident indexes; named patterns served (#2027) #2037/perf(gfql): use resident seed indexes in native Polars chains #2038 land.

Addendum (owner ask: the receipt quoted pandas only). This PR's product diff touches four functions on the pandas/cuDF chain entry (_try_chain_fast_path, _seeded_typed_hop_pandas_cudf, _seed_node_rows, _tag_fast_path_aliases) and no polars code path (the polars lane is #2038), so polars is unchanged by construction; measured anyway, same ladder as above at master 9226829 vs this head 4b91e9f (local box, medians of 7, ms; polars 1.42, cudf 25.10 on an RTX 3080 Ti):

• polars: every cell within noise of master (unchanged, as the diff predicts).
• cuDF: every cell faster than master (lookups 3–4.5×, indexed hop 3–4×), and master's inversion (indexed hop 35–44 ms slower than the unindexed 7–9 ms) is gone.
• Honest loss that stays: on cuDF the indexed seeded hop (8.7 / 14.5 / 14.5) is still slower than the unindexed one (7.7 / 9.2 / 9.6) and is not flat in table size the way pandas is. The pandas/cuDF lane pays device-side fixed costs on the index path (id-array conversions in _index_node_rows / _ids_to_key_array, and the alias tagging) that a plain cuDF filter does not. Not a regression against master and not this PR's scope to close; recorded in the plan's step-9 attribution as the cuDF lever, with the local-GPU caveat (dgx receipts for cuDF come from the master re-measure).