Fix #36: MergeBatch 合并搬移效率收益建模 (move_eff) + t_cmd_ns 置 0

用户澄清: MergeBatch vs IterBatch 的本质区别不只是 DMA 命令数 —— 合并 b0 个
batch 的左/右矩阵一起搬入 L1, 使单块 tile = nValue*dValue*dt 放大 b0 倍 (堆叠
方向视转置: A ND 非转置沿 M(nValue), B ND 非转置沿 N(dValue)), 搬移效率更高,
即便 T_cmd=0 也有效益。

- models.move_eff: 单命令搬移效率 eff = min(1, tile/min_TileSize) (16KB 饱和,
  与进入条件4效率下限语义同源); gm_move_time 按 A/B 两侧字节加权
  t = (V_A/eff_A + V_B/eff_B)/BW_gm; 只影响时间列, GM 字节量仍 = V_in
- IterBatch: l1_form 补驻留侧返回; move_tiles 分侧口径 (a/b 双侧整K, c 驻留侧
  整K+对侧k_l1, d 双侧k_l1), evaluate 接入效率加权
- MergeBatch: 合并 tile 放大 b0 倍接入效率加权; beats_iterbatch 净收益 =
  命令节省(cmds差×T_cmd) + 效率节省(t_data差) − drain惩罚, K截断且效率打平且
  T_cmd>0 时严格退化为 v1.1 §4.5 闭式; 退役 T_cmd<=0 策略特判
- router: 退役 "T_cmd<=0 策略优先 MergeBatch" 覆盖, 时延模型统一终审
- hardware: t_cmd_ns 50 -> 0 (未标定按 0; 合并收益不再依赖 T_cmd 估计值)
- 作用域: 仅切B 两分支接入 (逐命令 tile 小、效率差显著); ASW/StreamK 单命令
  tile 通常已饱和, 极端小 tile 走 issue#34 效率降级标注通道
- 用户 case 家族 B=128,M=1~16,N=128,K=512: m=1~8 -> MergeBatch (效率节省
  ~0.61us > drain), m=16 -> IterBatch (iter A tile 恰达 16KB 饱和, 效率打平,
  drain 决定); 分界与时延全家族一致
- demo: merge_demo_k_trunc 形状 (2048,32,32,256)->(2048,16,64,128) (原形状
  两侧 tile 均已 16KB 饱和, t_cmd=0 下无收益转 IterBatch; 新形状 iter A tile
  4KB eff=0.25 vs 合并 16KB eff=1.0, 保持 MergeBatch 胜出演示且仍 K截断)
- 测试: 74/74 (新增 TestIssue36 5 例: 效率曲线/字节不变/效率差胜出/家族;
  TestArbitration/TestZeroCmdHandling 按 t_cmd=0+效率语义重写; TestIssue35
  家族期望更新)
- 文档: 01_MergeBatch §4/§5 效率模型+泛化净收益; 02_IterBatch 口径注;
  00_总纲胜出条件; 01_软件架构 T_cmd 标定说明; 05 时间列效率口径注; README 要点
- 验证: examples 重生成可复现 0 diff; 压力 10000 例 0 崩溃/0 NaN/0 违规/
  0 GM<V_in, 七分支覆盖 (MergeBatch 386 例)

BMM/BMM_Theory/bmm_theory/router.py

@@ -4,12 +4,12 @@
   1. 前置归约: BatchA=1 或 BatchB=1 -> 转Matmul
                 K=0 / K=1 -> 特殊分支 (AIV 向量通路)
   2. B >= C 且 BatchA==BatchB: 切B -> IterBatch 与 MergeBatch 仲裁
-       仲裁规则 (v1.1 §4.5 统一分界):
-         MergeBatch 最优 <=> K截断(k_L1=K) 且 b_core > b0*(T_comp+T_write)/T_cmd
-         L1 绑定时 MergeBatch 恒劣于 IterBatch;
-       两分支同时合法时用端到端时延模型 T_total 仲裁;
-       例外: T_cmd<=0 (命令时延不可量化/未标定) 时, 指令级收益未建模,
-       按既定策略: K截断即可优先 MergeBatch (覆盖时延模型仅来自 drain/冗余的差额).
+       仲裁规则 (v1.1 §4.5 统一分界 + issue#35/#36 泛化):
+         净收益 = 命令节省(cmds 差 × T_cmd) + 搬移效率节省(合并 tile 放大 b0 倍,
+                  move_eff 模型) − drain 惩罚; K截断且效率打平时退化为文档闭式
+                  b_core > b0*(T_comp+T_write)/T_cmd;
+       两分支同时合法时用端到端时延模型 T_total 终审 (T_cmd 默认 0, 未标定;
+       合并效率收益已建模, 不再需要策略覆盖).
   3. StreamK 检查: P <= C/2 且满足切K条件 -> StreamK (B/M/N 买不满时买 K)
   4. 兜底: ASW_Basic 切 M/N (含降核模式)
 """
@@ -86,34 +86,22 @@ class BranchRouter:
 
         arbitration = ""
         if mb.capable and ib.capable:
-            # 统一分界条件 + 端到端时延仲裁双保险
+            # 统一分界条件 + 端到端时延仲裁双保险; 时延模型为最终裁决.
+            # (issue#36: 合并的搬移效率收益已由 move_eff 模型量化进时延模型,
+            #  T_cmd=0 默认下不再需要"T_cmd<=0 策略优先 MergeBatch"的覆盖逻辑)
             mb_win, detail = self.merge_batch.beats_iterbatch(case)
             t_mb = mb.timing.t_total
             t_ib = ib.timing.t_total
             lat_win = self.merge_batch.name if t_mb <= t_ib else self.iter_batch.name
             win = self.merge_batch.name if mb_win else self.iter_batch.name
-            # 冲突解决: 默认"时延模型为最终裁决"; 例外是 T_cmd<=0 且分界条件判
-            # MergeBatch 胜 (K截断) 的情形 —— 此时时延模型不含指令级收益
-            # (MergeBatch 搬移命令数/主机指令数省 b0 倍, 未量化), 按既定策略
-            # 优先 MergeBatch (时延模型内的差额只是 drain 惩罚/冗余, 方向已知小量).
-            policy_merge = (self.spec.t_cmd <= 0 and mb_win and
-                            win != lat_win and win == self.merge_batch.name)
-            if policy_merge:
-                arbitration = (
-                    f"两分支均合法, 仲裁: "
-                    f"[分界条件] MergeBatch最优={mb_win} ({detail}); "
-                    f"[时延模型] T_MergeBatch={t_mb*1e6:.2f}us vs T_IterBatch={t_ib*1e6:.2f}us -> {lat_win}更优; "
-                    f"[裁决] {win} (T_cmd<=0 策略: 命令/指令级收益未建模, 时延模型差异仅来自 "
-                    f"drain/冗余, 以 MergeBatch 优先策略裁决)")
-            else:
-                arbitration = (
-                    f"两分支均合法, 仲裁: "
-                    f"[分界条件] MergeBatch最优={mb_win} ({detail}); "
-                    f"[时延模型] T_MergeBatch={t_mb*1e6:.2f}us vs T_IterBatch={t_ib*1e6:.2f}us -> {lat_win}更优; "
-                    f"[裁决] {lat_win}" + ("" if win == lat_win else
-                        f" (分界条件判{win}, 与时延模型不一致, 以时延模型为准)")
-                )
-                win = lat_win  # 时延模型为最终裁决
+            arbitration = (
+                f"两分支均合法, 仲裁: "
+                f"[分界条件] MergeBatch最优={mb_win} ({detail}); "
+                f"[时延模型] T_MergeBatch={t_mb*1e6:.2f}us vs T_IterBatch={t_ib*1e6:.2f}us -> {lat_win}更优; "
+                f"[裁决] {lat_win}" + ("" if win == lat_win else
+                    f" (分界条件判{win}, 与时延模型不一致, 以时延模型为准)")
+            )
+            win = lat_win  # 时延模型为最终裁决
         elif any(capable.values()):
             win = next(n for n, v in capable.items() if v)
             arbitration = f"仅 {win} 条件满足"