fix(Phase2Translator): 并行 worker 数不再按可用内存降级串行，改为"预分配校验 + 强制预留"（TPC_JOBS 可显式覆盖）

现象：同一条命令的编译时间在 ~400s 与 ~1180s 两档之间随机跳（PROF 目录当日
366s~2239s），用户反馈"耗时不降反增"。

根因（三份 profile 实证）：
- 旧 _PickWorkerCount 用 `by_mem = max(1, avail_mb // per_worker_mb)` 按**可用**
  物理内存夹 worker 数：可用稍紧（<~2.8GB）就整体降为 1 ⇒ **静默退回串行**。
  其文档字符串自己就写着"76 文件逐个翻译 1180s，并行时 ~400s，波动 2-3 倍"。
- PROF/20260930_224857（438.40s）：主进程 _translate_file **0 次**、
  StructGen/HandlesImports/HandlesClassDef **0 条记录**、总调用 7.28 亿
  ⇒ 翻译在 worker 进程里做完了（未 profile），主进程只在等 → **并行档**。
- PROF/20260930_231916（1048.55s）与 20260930_235354（1168.15s）：
  _translate_file **75 次全在主进程**、_parallel_translate_worker/_batch 0 次、
  总调用 19.6 亿 ⇒ **串行档**（1180s 档）。
⇒ 拿 438s 当基线比 1168s 是"并行 vs 串行"。本次 A/B（同为串行、总调用
  19.616 亿 vs 19.631 亿）里各项优化均为正收益（_RewritePlain −5.0s、
  __exit__ −1.5s、re.match+_compile −1.3s、_RewriteQuoted −0.75s…）；
  +12% 属机器波动（同一批 C 函数在调用次数不变下变慢 25%~73%）。

改动（口径由用户定：不降级 + 预分配内存避免波动 + 强制要求预留内存）：
1. **不降级**：删掉"内存紧就退串行"。worker 数 = min(cpu_count, n_files)，
   不再因可用内存抖动而变化。
2. **预分配校验 + 强制预留**：新增 _MemStatus()（读可用/总量）与
   _ProbeReserveMb()——按 base×per_worker_mb（翻译 350 / 编译 400）分块**真正
   提交**该预算（峰值=预算），成功后立即整体释放，紧接其后创建 worker 进程
   由 OS 复用这批页。等于先向 OS 确认"这笔预算确实拿得到"，而不是只看含大量
   可回收页的 ullAvailPhys。
3. **fail-fast**：可用内存 < 预算、或预分配校验提交失败 ⇒ RuntimeError 报出
   "需要 X MB（N worker × M MB）/ 当前可用 Y MB / 总量 Z MB"，由使用者释放内存
   或**显式** TPC_JOBS=N 重跑（N=1 即显式接受串行）。不再静默降级。
4. 新增 TPC_JOBS=N 显式覆盖（跳过校验，使用者自担内存风险）。
5. 每次决策都打日志：显式指定 / 读不到内存状态 / 预分配校验耗时 / 最终 workers。

已知取舍：内存确实不足时编译会**直接失败**（这是"不降级"的应有语义），出路是
释放内存或 TPC_JOBS=N；预分配校验会短暂占用峰值=预算的内存（约 1GB/秒级耗时）。

未动（下一步候选）：串行档的真热点 StructGen._generate_structs（151s 自身 /
480s 累计，被调 36,389 次≈每类 22 次，O(类数²)）。

lib/Projectrans/Phase2Translator.py

@@ -447,21 +447,18 @@ def _ParseDwarfSubprograms(dump_text: str) -> list[tuple[int, int, str]]:
     return result
 
 
-def _PickWorkerCount(n_files: int, per_worker_mb: int = 350) -> int:
-    """按可用物理内存动态限制并行 worker 数，避免多进程编译内存峰值 OOM。
+# 显式并行度覆盖：TPC_JOBS=N（N>=1）——使用者明确指定 worker 数并**自行承担**
+# 内存风险（含 N=1 即显式接受串行）。设了它就不再走内存校验/预分配。
+_JOBS_ENV: str = 'TPC_JOBS'
+# 已通过"预分配校验"的预算（MB）：同一预算不重复校验（翻译/编译两阶段各查一次）
+_MemProbeDone: set[int] = set()
+# 预分配校验的分块大小（MB）：分块提交并**全部持有**到校验结束（峰值 = 预算），
+# 结束后立即整体释放 —— 紧接其后就创建 worker 进程，OS 直接复用这批刚释放的页。
+_MEM_PROBE_CHUNK_MB: int = 256
 
-    单 worker 预估 per_worker_mb（Python 解释器 + llvmlite module + 共享
-    符号表快照）；系统可用内存不足时降为单 worker 串行，内存充足时回落到
-    cpu_count 并行。Windows 用 GlobalMemoryStatusEx 读 ullAvailPhys。
 
-    per_worker_mb=350（2026-08-22 从 700 调低）：实测翻译阶段 worker 稳态
-    内存 ~110MB（tasklist 观察）、峰值 ~300MB；原 700MB 过保守——可用内存
-    稍紧（<2.8GB）就整体降级单 worker 串行，76 文件逐个翻译 1180s，并行
-    时 ~400s，时间波动 2-3 倍（用户反馈"编译时间不稳定"的根因之一）。
-    """
-    base = min(os.cpu_count() or 4, n_files)
-    if base <= 1:
-        return base
+def _MemStatus() -> tuple[int, int]:
+    """(可用物理内存 MB, 物理内存总量 MB)；读取失败返回 (-1, -1)，调用方按"未知"处理"""
     try:
         import ctypes
 
@@ -481,11 +478,97 @@ def _PickWorkerCount(n_files: int, per_worker_mb: int = 350) -> int:
         stat = _MemStat()
         stat.dwLength = ctypes.sizeof(_MemStat)
         if ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(stat)):
-            avail_mb = stat.ullAvailPhys // (1024 * 1024)
-            by_mem = max(1, avail_mb // per_worker_mb)
-            return max(1, min(base, by_mem))
+            return (stat.ullAvailPhys // (1024 * 1024),
+                    stat.ullTotalPhys // (1024 * 1024))
     except Exception:
         pass
+    return (-1, -1)
+
+
+def _ProbeReserveMb(mb: int) -> bool:
+    """预分配校验：一次性提交 mb MB（分块持有后整体释放），成功返回 True。
+
+    为什么要"预分配"而不是只读 ullAvailPhys：可用物理内存含大量**可回收**的
+    缓存页/其他进程随时会吃掉的余量，只按它决策会出现"这一秒够、真跑起来不够"
+    的波动（编译时间在 400s / 1180s 两档之间随机跳的直接来源）。先真正把预算
+    拿到手（页级提交）再放掉，等于向 OS 确认过这笔预算确实可分配。
+    """
+    if mb <= 0:
+        return True
+    Bufs = []
+    Left = mb
+    try:
+        while Left > 0:
+            Cur = min(_MEM_PROBE_CHUNK_MB, Left)
+            Bufs.append(bytearray(Cur * 1024 * 1024))
+            Left -= Cur
+        return True
+    except MemoryError:
+        return False
+    finally:
+        del Bufs
+
+
+def _PickWorkerCount(n_files: int, per_worker_mb: int = 350) -> int:
+    """并行 worker 数的**唯一**决策入口（CPU 上限 + 内存预分配双约束）。
+
+    口径（用户 2026-10-01 定，取代旧"内存紧就降级串行"）：
+      1. **不降级**：内存不足**绝不**静默退回单 worker 串行 —— 旧实现 `by_mem =
+         max(1, avail_mb // per_worker_mb)` 在可用内存稍紧时就整体降为串行，
+         同一条命令 76 文件逐个翻译 1180s、并行 ~400s，时间随机跳 2-3 倍
+         （profile 实证：224857 那次主进程 0 次 _translate_file＝并行，438s；
+          231916/235354 两次主进程 75 次 _translate_file＝串行，1048s/1168s）。
+      2. **预分配 + 强制预留**：先按 base×per_worker_mb 做一次性提交校验
+         （_ProbeReserveMb），拿到就并行、拿不到就 fail-fast 报出"可用/需要"
+         数字，由使用者释放内存或**显式** TPC_JOBS=N 接受其它并行度。
+      3. 显式 TPC_JOBS=N 优先且跳过校验（使用者自行承担内存风险，N=1 即显式串行）。
+
+    单 worker 预估 per_worker_mb（Python 解释器 + llvmlite module + 共享符号表
+    快照）；实测翻译阶段 worker 稳态 ~110MB、峰值 ~300MB，故取 350（编译阶段
+    调用方传 400）。Windows 用 GlobalMemoryStatusEx 读物理内存。
+    """
+    base = min(os.cpu_count() or 4, n_files)
+    if base <= 1:
+        return base
+    env_jobs: str | None = os.environ.get(_JOBS_ENV)
+    if env_jobs:
+        try:
+            want = int(env_jobs)
+        except ValueError:
+            want = base
+        want = max(1, min(want, base))
+        _vlog().info(
+            f"  [并行] {_JOBS_ENV}={env_jobs} → workers={want}"
+            f"（显式指定，跳过内存校验与预分配）")
+        return want
+    avail_mb, total_mb = _MemStatus()
+    need_mb = base * per_worker_mb
+    if avail_mb < 0:
+        # 读不到内存信息：不阻塞编译（按 CPU 上限并行），但必须显式告知
+        _vlog().warning(
+            f"  [并行] 无法读取物理内存状态，按 CPU 上限取 workers={base}"
+            f"（预算 {need_mb}MB）")
+        return base
+    if avail_mb < need_mb:
+        # 不降级：报数字 + 两条出路（释放内存 / 显式 TPC_JOBS=N）
+        raise RuntimeError(
+            f"[并行翻译] 内存不足，拒绝降级为串行（串行会让编译时间从 ~400s 掉到 ~1180s 档）："
+            f"需要预留 {need_mb}MB（{base} worker × {per_worker_mb}MB），"
+            f"当前可用 {avail_mb}MB / 总量 {total_mb}MB。"
+            f"请释放内存后重跑；若确实要少开 worker（含串行），显式设 {_JOBS_ENV}=N 重跑。")
+    if need_mb not in _MemProbeDone:
+        _t0: float = _time.time()
+        if not _ProbeReserveMb(need_mb):
+            raise RuntimeError(
+                f"[并行翻译] 预分配校验失败：无法一次性提交 {need_mb}MB"
+                f"（{base} worker × {per_worker_mb}MB；可用显示 {avail_mb}MB / 总量 {total_mb}MB）。"
+                f"请释放内存后重跑；若确实要少开 worker（含串行），显式设 {_JOBS_ENV}=N 重跑。")
+        _MemProbeDone.add(need_mb)
+        _vlog().info(
+            f"  [并行] 预分配校验通过：{need_mb}MB 可一次性提交"
+            f"（{_time.time() - _t0:.2f}s，已释放待 worker 进程复用）")
+    _vlog().info(
+        f"  [并行] workers={base}（预算 {need_mb}MB ≤ 可用 {avail_mb}MB / 总量 {total_mb}MB）")
     return base