Summary:
Fuse each gemma4_31b MLP's gate_proj|up_proj into a single
[2*intermediate, hidden] coalesced-int4 matmul, applied by default in the CUDA
export. This issues one activation-quant + one W4A8 matvec per layer instead of
two, cutting per-token launch + activation-quant overhead in the launch-bound
decode path. Only Q4_K (CudaCoalescedInt4Tensor) gate/up pairs are fused; any
other quant type (e.g. Q6_K) is left as two matmuls (guarded, still correct).

Builds on the already-landed kv_len-bounded tq4_sdpa kernel + gemma4_31b
call-site (kv_len + mask_is_causal), which recovered 128k decode from ~2.8 to
~43 tok/s. With both, ET gemma4_31b 128k+TurboQuant decode beats llama.cpp at
every measured context (cuda_graph ON):

  ctx    ET      llama
  512    44.80   42.77
  2K     43.20   41.97
  8K     42.23   41.23
  32K    41.64   40.27
  127K   38.41   35.97

TurboQuant KV compression kept; prefill restored (6-8x) with no regression;
output quality preserved.

Test Plan:
- Fusion numerics: fused vs unfused MLP through the real W4A8 int4_plain_mm
  kernel = bit-exact (max_abs_diff 0.0, cos 1.000000) for decode (T=1) and
  prefill (T=4).
- Export + run: fused module exported via CudaPartitioner and executed through
  executor_runner (RC=0, cos 0.999915 vs eager). Full 31B export logs
  "Fused gate+up on 60 MLP layers".
- Decode A/B (gemma4_31b 128k+TQ, cuda_graph ON, 5x median): table above; beats
  llama.cpp at 512 -> 127K. nsys: tq4_sdpa 91.7% -> 2.9% of decode.

…stic prefill autotune

- Global (full-attention) bf16 layers: bound SDPA to a runtime kv_len scalar
  (CUDA-graph-safe) instead of the full max_seq_len KV buffer -> O(context)
  decode; restores decode scaling (was flat ~36.5 t/s at all depths ->
  46.5@512, 34.9@127K). (sdpa.py kv_len path + cuda_source_transformations.py
  _lenaware_attention_forward; global layers only, sliding + turbo untouched)
- Prefill global full-attention: replace fixed m32/m64 BLOCK_M selection with a
  head_dim-keyed autotuned _sdpa_fwd_kernel + register-budget prune
  (BLOCK_M*HEAD_DIM <= 4096*num_warps), fixing acc[64,512] fp32 register spill
  at head_dim=512. Prefill +24% @8K, +63% @32k, +117% @127k; head_dim-agnostic
  (no split-D needed for D<=512). (sdpa.py)
- Validated: output bitwise-identical to prior kernel (cos=1.0, D=64/128/256/512),
  no decode regression; non-tq prefill now beats llama.cpp at all 5 cells and
  turbo TQ4 at 4/5. Op-level autotune profiling (A100) confirms the config set is
  near-optimal (in-set optimum at every regime; only <=1.3% marginal candidates).

…tune

Prefill (global head_dim=512 TQ4 path):
- Consolidate m64/m32 into one no-spill _tq4_sdpa_prefill_kernel (BLOCK_M<=32
  so acc[BLOCK_M,512] fp32 stays in registers, no spill).
- Absolute-offset analytic causal (offs_n > (kv_len-Lq)+seq_pos); kernel no
  longer reads a materialized causal mask.
- Prune prefill autotune list to the heavy-kv optima; also removes BLOCK_N=16
  configs that produced incorrect output.

Decode (split-K): retune autotune list for the HAS_MASK=False path - add the
profiled optima (BLOCK_N=32/w4/s2, BLOCK_N=64/w8/s3), drop configs that are
catastrophic at HAS_MASK=False (BLOCK_N=64/w2, BLOCK_N=128/w4).

Call-site passes attn_mask=None for BOTH prefill and decode so the two exported
methods share one AOTI weights blob (avoids 2x .ptd weight duplication).

e2e @127k (A100, vs same-tree baseline): prefill 543->715 t/s (1.32x), decode
34.1->34.5 t/s, peak 25.75 GB (zero extra memory). Smaller contexts beat llama
on both prefill and decode.

…ates