Add ProcessRouter for physics-process-based expert gating

Routes on the physics process (Compton, phot, brems, ...) that ends a
step, supervised by a small classifier since process is a post-step
outcome unobservable at gate time. Threads a process label end-to-end
through the data pipeline (loader, build_features, dataset batches,
training loss/checkpointing) alongside the existing EnergyRouter.

giant/data/loader.py

@@ -95,6 +95,16 @@ def _df_to_dict(df: pd.DataFrame) -> dict[str, np.ndarray]:
         "layer_id": df["layer_id"].to_numpy(dtype=np.int32),
         "n_sec": df["child_track_ids"].apply(len).to_numpy(dtype=np.int32),
         "e_sec": df["e_sec"].to_numpy(dtype=np.float32),
+        # The physics process that ended the step (e.g. "compt", "phot",
+        # "eBrem") — a post-step outcome, so it's a router/classifier
+        # supervision label only, never conditioning (see build_process_map*
+        # / ProcessRouter). Guarded like has_sec_lists: older parquet
+        # conversions predating this column still load fine.
+        "process": (
+            df["process"].to_numpy(dtype=object)
+            if "process" in df.columns
+            else np.full(len(df), "", dtype=object)
+        ),
         "step_length": df["step_length"].to_numpy(dtype=np.float32),
         "post_E": df["post_E"].to_numpy(dtype=np.float32),
         "delta_e": (df["pre_E"] - df["post_E"]).to_numpy(dtype=np.float32),
@@ -192,3 +202,30 @@ def build_index_maps_from_files(
         {v: i for i, v in enumerate(sorted(pdg_vals))},
         {v: i for i, v in enumerate(sorted(mat_vals))},
     )
+
+
+def build_process_map_from_files(
+    files: list[Path], n_experts: int
+) -> dict[str, int]:
+    """Scan the `process` column and build a frequency-capped process->index map.
+
+    Physics processes have a long tail (rare nuclear captures, decays, ...)
+    while `ProcessRouter` needs a fixed number of expert slots, so only the
+    `n_experts - 1` most frequent processes get their own index; every rarer
+    process is bucketed into a shared "other" index (`n_experts - 1`). This
+    mirrors how `build_features` clamps the n_sec label to K_MAX for the
+    fixed-width n_sec_head classifier.
+    """
+    counts: dict[str, int] = {}
+    for path in files:
+        df = pd.read_parquet(path, columns=["process"])
+        for name, count in df["process"].value_counts().items():
+            name = str(name)
+            counts[name] = counts.get(name, 0) + int(count)
+    ranked = sorted(counts, key=lambda name: counts[name], reverse=True)
+    keep = ranked[: max(n_experts - 1, 0)]
+    proc_map = {name: i for i, name in enumerate(keep)}
+    other_idx = n_experts - 1
+    for name in ranked[len(keep) :]:
+        proc_map[name] = other_idx
+    return proc_map