refactor(forward): lift moe_ffn_layer helper (M32d Day 1 prep, #1830 PR-2 of 4)

[noahgift]

Summary

Pure refactor of the per-position MoE FFN block (pre-norm + dispatch + residual) into a private helper method on `OwnedQuantizedModel`. Behavior is byte-identical to the previous batched-norm + per-position-dispatch + outer-residual version.

Second of 4 PRs implementing #1830 (M32d KV cache for qwen3_moe inference path).

Cascade progress

#	What	Status
#1831	Extract `attention_layer_with_cache` helper from dense path	Open
#1832 (this)	Extract `moe_ffn_layer` helper from `forward_qwen3_moe`	This PR
PR-3	Add `forward_single_qwen3_moe_with_cache` + wire generate loop	Next
PR-4	`moe_kv_cache_equivalence` integration test	After PR-3

After PR-1 + PR-2 land, PR-3 becomes a small composition: per layer, call `attention_layer_with_cache` then `moe_ffn_layer`.

What changed

• `forward_qwen3_moe.rs` lines 224-260 (the per-layer 2f Pre-FFN-norm + 2g MoE FFN dispatch + residual block) lifted into a new private method `moe_ffn_layer`.
• Outer for-position loop in `forward_qwen3_moe` now calls the helper once per position via a temporary `tok_hidden` buffer.

Helper signature follows the spec:

```rust
pub(crate) fn moe_ffn_layer(
&self,
hidden_token: &mut [f32], // [hidden_dim], single token
layer: &OwnedQuantizedLayer, // for ffn_norm_weight + bias
moe_layer: &Qwen3MoeQuantizedLayer, // for router + experts
num_experts: usize,
num_experts_per_tok: usize,
moe_intermediate: usize,
data: &[u8],
use_rmsnorm: bool,
) -> Result<()>
```

Math equivalence

The previous batched code:

1. Compute `ffn_input = rms_norm(hidden)` over `seq_len * hidden_dim` (rms_norm is per-vector, so this is N independent calls inlined)
2. For each position `s`: `pos_out[s] = moe_ffn_forward_layer(ffn_input[s])`
3. Residual: `hidden += ffn_output`

The new per-position code does the same math in a different order:

```
for s in 0..seq_len:
norm(hidden[s..s+hidden_dim]) → ffn_input
moe_ffn_forward_layer(ffn_input) → pos_out
hidden[s..s+hidden_dim] += pos_out
```

`rms_norm`/`layer_norm` are per-vector (only mix elements within one `hidden_dim` vector, never across tokens), so batching them is convenience, not required for correctness. The per-token MoE dispatch was already the structure.

Cost note

Adds two per-position copies: `hidden→tok_hidden` and `tok_hidden→hidden`. For Qwen3-Coder-30B (`hidden_dim=2048`, f32) each copy is 8KB — negligible vs the per-expert matvecs inside `moe_ffn_forward_layer` (~6MB Q4_K bytes per expert × top-K=8 selected experts).

Test plan

• `cargo check -p aprender-serve --lib --features cuda` → clean
• `cargo test gguf::inference::forward` → 109 passed / 0 failed / 2 ignored
• `cargo test qwen3_moe` → 17 passed / 0 failed / 0 ignored

Cross-refs

• Issue: M32d: KV cache for qwen3_moe inference path (engineer-driven, 1-2 week) #1830 (M32d KV cache for qwen3_moe inference path)
• Predecessor: refactor(forward): lift attention_layer_with_cache helper (M32d Day 1 prep, #1830 PR-1 of 4) #1831 (PR-1: attention helper)
• Spec: `docs/specifications/m32d-moe-kv-cache-scope.md`
• Contract gate (downstream, blocked by full M32d): FALSIFY-QWEN3_MOE_SERVE_DISPATCH_V1_004

🤖 Generated with Claude Code

[noahgift]

Superseded by #1832 — operator flipped from Option (b) engineer-driven to Option (a) in-session and shipped the full M32d KV cache feature monolithically (without the helper extraction this PR proposed). #1832 ships forward_single_qwen3_moe_with_cache + cache-aware run_qwen3_moe_generate + moe_kv_cache_equivalence test + m32d_perf bench with empirical 19× speedup. Closing this prep refactor PR; not needed once #1832 lands.

This is the standard chain-PR squash-leapfrog cleanup pattern (memory: feedback_chain_pr_squash_leapfrog.md).