fix(unified-memory): forward the KV-index translator through every wrapper backend

[caihuali95]

Motivation

AttentionBackend.kv_index_translator is a class attribute that defaults to
None. A backend that wraps another and does not re-expose the inner
backend's copy therefore answers "this backend needs no translation".

Every producer that reaches the translator through the live backend rather
than through a runner then skips translation silently. The MLA
chunked-prefix-cache path is one:
ForwardBatchDeepseekMHAMixin.prepare_chunked_kv_indices reads
get_attn_backend().kv_index_translator and translates only
if src is not None, so it hands the kernel raw virtual ids for the shared prefix.
Nothing raises — virtual and physical ids share a value range, so the gather
simply reads the wrong rows.

Hybrid models (mamba/GDN + full attention) serve every forward through
HybridLinearAttnBackend, which forwards the pool and req_to_token but not
the translator. Three other wrappers have the same omission.

The damage needs all three of: --enable-unified-memory (translation actually
required), an MLA backend (only fa3 / flashinfer / flashmla take the
chunked-prefix path; Triton does not), and a radix cache (only then is there a
shared prefix to read back). On Kimi-Linear-48B that is gsm8k 0.89–0.92 →
0.05–0.31 on six of six such cells, while the same configuration on Triton,
and every chunked-prefill cell, stays correct.

Modifications

Four wrappers need the forward, not one. They spell the wrapped field
full_attn_backend, prefill_backend/decode_backend, backend/swa_backend
and dense, so nothing keyed on the attribute name finds them all:

• layers/attention/hybrid_linear_attn_backend.py — from the full-attention
  backend, beside the pool and req_to_token it already forwards.
• layers/attention/hybrid_attn_backend.py — from the model runner, which is
  where it already takes the pool.
• layers/attention/dots_hybrid_backend.py — twice: the DSA wrapper from its
  inner backend, the SWA/MLA wrapper from its swa backend.
• layers/attention/minimax_sparse_backend.py — the hybrid wrapper, from its
  dense backend.

mem_cache/kv_index_translator.py — assert_backends_carry_translator, which
refuses at boot when a reachable backend carries someone else's translator or
none at all, and is inert on a pool that needs no translation.

model_executor/model_runner.py — run that guard over the built backends, right
after they are constructed. Adding a forward is easy to forget in a new
wrapper and the failure is silent by construction, so the runtime check is what
makes it loud.

test/registered/unit/layers/attention/test_kv_translate_ownership.py — an
object-graph test in the file that already owns translator ownership. It
builds a live instance of every wrapper and gives only the inner that must
supply the translator a copy; every other inner carries None. A wrapper that
copies from the linear / sparse / DSA side ends up with None and fails — a
source scan cannot see that.

Derived, not enumerated: a wrapper is any AttentionBackend subclass taking
another AttentionBackend as a constructor parameter, so a new one is covered
the day it is written, and a completeness test asserts the derived set equals
the set with instances. The derivation is per class, not per file: an
earlier revision of this PR scanned whole files, which passes as soon as any one
class in a file forwards — and hybrid_linear_attn_backend.py holds four
AttentionBackend subclasses and one forward, so it covered the very file the
bug lived in. Seven wrappers come out, including ShortConvHybridAttnBackend
and TboAttnBackend.

Verified by injection, each red on the new test and green on the old scan: drop
the HybridLinear forward while leaving an unrelated
self.kv_index_translator = None in that file; point MiniMax at
sparse_backend; add a wrapper with no instance.

test/registered/models_e2e/test_kimi_linear_models.py — the damage guard.
assert_backends_carry_translator only fires when a wrapper is actually built,
and no per-PR job pairs the unified pool with an MLA model, so nothing reached
the chunked-prefix / MHA-one-shot producer. This file is already base-b on
2-gpu-large and already launches Kimi-Linear twice, so the cost is one more
server start in an allocated job rather than a new 4-GPU job. est_time
600 → 900. The nightly test_kimi_linear_unified_memory.py keeps its copy: it
resolves a different default backend on its H100 runner.

Red-then-green on that cell: 0.37 not >= 0.88 on main without the fix,
passing on this head.

Accuracy Tests

Kimi-Linear-48B-A3B-Instruct, tp2, --enable-unified-memory, radix cache,
gsm8k (n=200 per cell), unified vs baseline:

cell	before	after
radix cg_off fa3	0.925 → 0.120	0.910 → 0.895
radix cg_off flashinfer	0.905 → 0.110	0.905 → 0.900
radix cg_off flashmla	0.905 → 0.270	0.900 → 0.895
radix cg_on fa3	0.900 → 0.200	0.905 → 0.900
radix cg_on flashinfer	0.900 → 0.105	0.900 → 0.910
radix cg_on flashmla	0.895 → 0.050	0.900 → 0.885

All six back within ±0.015 of baseline. The always-correct cells (chunked
prefill, Triton) are unchanged.

Whole matrix, 68 cells / 240 gsm8k runs across Kimi, Qwen3.5-9B, gpt-oss-20b,
Falcon-H1-7B and Llama-3.1-8B on triton / fa3 / flashinfer / flashmla:
112 baseline-vs-unified pairs, median +0.005, zero Kimi outliers, 240 ok /
0 crashed. The residual outliers are all gpt-oss, whose scores sit near 0.5
where the binomial sigma at n=200 is ~0.05.

Checklist

• Format your code according to the Format code with pre-commit.
• Add unit tests according to the Run and add unit tests.
• Update documentation according to Write documentations.
• Provide accuracy and speed benchmark results according to Test the accuracy and Benchmark the speed.
• Follow the SGLang code style guidance.

---

CI States

Latest PR Test (Base): ❌ Run #33463751335
Latest PR Test (Extra): ❌ Run #33463751148
Latest PR Test (AMD ROCm 7.2): ❌ Run #33463751216