feat(conversions): cutlass FP8 e4m3 per-channel + compile_target/metadata tagging

[KavinKrishnan]

Summary

Trainer-side half of the design fix for the live coworker complaint that prime-rl breaks on Qwen3-MoE with cutlass kernels. The receiver-side filtering API is already shipped in ai-dynamo/modelexpress#349 (Phase 3a/3b on kavink/post-2389-phase3-4); this PR is the registry-side that produces tags that PR can filter on.

Draft because it depends on the Phase 2 graduation (draft #1) landing before the publisher actually emits the new `compile_target` / `compile_metadata` fields onto the wire. The registry extensions themselves are useful immediately — `select_default_conversion` now stops raising `NotImplementedError` for cutlass-format checkpoints, and the per-channel quantize helpers are unit-tested + ready to swap into any existing trainer-side path.

Registry plumbing

`ConversionEntry` gains two safe-default fields:

• `compile_target: str = "hf_raw"`
• `compile_metadata: dict[str, Any] = {}`

Mirrors the canonical strings in `modelexpress.shape_descriptors` (Phase 3a) without a cross-repo import dependency. Existing entries tagged retroactively: `bf16_cast`/`fp32_cast` → `hf_raw`, `fp8_128x128` → `deep_gemm_fp8` with metadata `{block_size: [128,128], scale_layout: "blockwise", dtype: "e4m3"}`.

`select_default_conversion` refactored to a table-driven design — `_DEFAULT_RULES: list[(predicate, name)]` walked in order. Adding a new kernel = one new module that calls `register(...)` + `register_default_rule(predicate, name)`. Predicates that raise on a malformed config are treated as "doesn't match" and skipped, keeping the resolver robust to model-card weirdness.

The `AutoConfig` import was hoisted into the function body so the registry loads without requiring `transformers` (tests + tooling don't need HF download capability).

New conversion: `cutlass_fp8_e4m3_per_channel`

Property	Value
Quant dtype	FP8 e4m3 (max 448)
Scale layout	per-output-channel
2D shape	weight `(out, in)` → scale `(out,)`
3D shape	weight `(E, out, in)` → scale `(E, out)`
Reduction axis	innermost (`axis=-1`)
`compile_target`	`"cutlass_fp8"`
`compile_metadata`	`{dtype, scale_layout, scale_axis, activation_scheme}`

Default-resolver predicates:

1. `quant_method="fp8"` + `quant_format="cutlass"` (explicit)
2. `quant_method="fp8"` + `weight_block_size=None` + `activation_scheme="dynamic"` (vLLM's published convention)

Both run after the deep-gemm rule, so models with `block_size=[128,128]` AND `activation_scheme="dynamic"` still resolve to `fp8_128x128` — regression-tested.

Tests

19/19 green via `python3 -m pytest tests/unit/train/models/conversions/test_cutlass_fp8.py`, direct-load + `transformers` stub so no HF download needed.

Categories:

• Per-channel quantize helper: 2D/3D shape, 1D rejection, bf16 dequant accuracy (≤5% median rel error), into-buffer write.
• Registry: existing entries retain correct `compile_target` + `compile_metadata`, cutlass entry registered + listed, default-rule insert/append ordering, unknown-quant error message lists registered names.
• Default-resolver dispatch: no-quant → bf16, [128,128] → fp8_128x128, `quant_format=cutlass` → cutlass, no block_size + dynamic → cutlass, deep-gemm wins when both rules match.
• Conversion fn dispatch: 2D linear correctness, 3D MoE correctness, `requires_scale=True` enforced.

Adding more kernels later

One module per kernel, ~80 LOC each:

```python
def my_kernel_quantize(src, out, scale_out): ...
register("my_kernel", my_kernel_quantize, requires_scale=True,
compile_target="my_kernel",
compile_metadata={...})
register_default_rule(lambda quant: quant.get(...) == ..., "my_kernel")
```

Future candidates: `cutlass_fp8_e4m3_per_token`, `awq_int4`, `gptq_int4`, `mxfp4`, `trtllm_w4a16`.

Test plan

• 19/19 new unit tests pass
• No regression on existing `bf16_cast` / `fp8_128x128` entries (covered by registry tests + the existing `test_qwen3_moe.py` which exercises both via `select_default_conversion`)
• Cluster validation on a real Qwen3-MoE cutlass FP8 checkpoint (deferred; requires a cutlass-quantized checkpoint to be available)
• After Phase 2 graduation lands, plumb `ConversionEntry.compile_target` + `compile_metadata` into `MxV2TrainingPublisher` at publish time so receivers can filter via `discover_v2_sources(compile_target_filter=…)` (follow-up PR)

Context

• Base RFC: `docs/proposals/post-pr2389-kernel-compile-plan.md` on the base branch.
• Sister PR (MX side): #349 — receiver-side filtering API.
• Sister PR (rendezvous): #1 — Phase 2 heartbeat/dedup/same-rank filter.
• Coworker complaint that motivated this work: prime-rl breaking on Qwen3-MoE + cutlass + non-128x128 quant.