chore(Phase2Translator): 自动并行度上限 8 worker，并精简并行提示文案

- 新增 _MAX_WORKERS=8（用户定：16 worker 太多，收益不足而内存压力翻倍）；
  只约束自动取值，显式 TPC_JOBS=N 仍按硬件/文件数上限
- 并行相关的 RuntimeError 与日志精简为一行数字 + 出路，去掉"拒绝降级为串行 /
  串行会让编译时间从 ~400s 掉到 ~1180s 档"等长说明

lib/Projectrans/Phase2Translator.py

@@ -454,7 +454,10 @@ _JOBS_ENV: str = 'TPC_JOBS'
 _MemProbeDone: set[int] = set()
 # 预分配校验的分块大小（MB）：分块提交并**全部持有**到校验结束（峰值 = 预算），
 # 结束后立即整体释放 —— 紧接其后就创建 worker 进程，OS 直接复用这批刚释放的页。
-_MEM_PROBE_CHUNK_MB: int = 256
+_MEM_PROBE_CHUNK_MB: int = 256
+# 自动并行度上限（用户 2026-10-01 定：16 worker 太多）。只约束**自动**取值，
+# 显式 TPC_JOBS=N 仍按硬件/文件数上限生效。
+_MAX_WORKERS: int = 8
 
 
 def _MemStatus() -> tuple[int, int]:
@@ -513,6 +516,8 @@ def _PickWorkerCount(n_files: int, per_worker_mb: int = 350) -> int:
     """并行 worker 数的**唯一**决策入口（CPU 上限 + 内存预分配双约束）。
 
     口径（用户 2026-10-01 定，取代旧"内存紧就降级串行"）：
+      · **自动上限 `_MAX_WORKERS`=8**：16 worker 收益不足、内存压力翻倍（用户 2026-10-01 定）；
+        显式 TPC_JOBS 不受此限（只受硬件/文件数约束）。
       1. **不降级**：内存不足**绝不**静默退回单 worker 串行 —— 旧实现 `by_mem =
          max(1, avail_mb // per_worker_mb)` 在可用内存稍紧时就整体降为串行，
          同一条命令 76 文件逐个翻译 1180s、并行 ~400s，时间随机跳 2-3 倍
@@ -527,7 +532,8 @@ def _PickWorkerCount(n_files: int, per_worker_mb: int = 350) -> int:
     快照）；实测翻译阶段 worker 稳态 ~110MB、峰值 ~300MB，故取 350（编译阶段
     调用方传 400）。Windows 用 GlobalMemoryStatusEx 读物理内存。
     """
-    base = min(os.cpu_count() or 4, n_files)
+    hw_max = min(os.cpu_count() or 4, n_files)
+    base = min(hw_max, _MAX_WORKERS)
     if base <= 1:
         return base
     env_jobs: str | None = os.environ.get(_JOBS_ENV)
@@ -536,39 +542,29 @@ def _PickWorkerCount(n_files: int, per_worker_mb: int = 350) -> int:
             want = int(env_jobs)
         except ValueError:
             want = base
-        want = max(1, min(want, base))
-        _vlog().info(
-            f"  [并行] {_JOBS_ENV}={env_jobs} → workers={want}"
-            f"（显式指定，跳过内存校验与预分配）")
+        # 显式指定只受硬件/文件数约束（不受 _MAX_WORKERS 限制），并跳过内存校验
+        want = max(1, min(want, hw_max))
+        _vlog().info(f"  [并行] {_JOBS_ENV}={env_jobs} → workers={want}（显式指定，跳过校验）")
         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）")
+        # 读不到内存信息：不阻塞编译（按上限并行），但必须显式告知
+        _vlog().warning(f"  [并行] 读不到物理内存，取 workers={base}（预算 {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 重跑。")
+            f"[并行翻译] 内存不足：需 {need_mb}MB（{base}×{per_worker_mb}MB），"
+            f"可用 {avail_mb}MB/{total_mb}MB；释放内存或设 {_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 重跑。")
+                f"[并行翻译] 预分配 {need_mb}MB 失败（{base}×{per_worker_mb}MB，"
+                f"可用 {avail_mb}MB/{total_mb}MB）；释放内存或设 {_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）")
+        _vlog().info(f"  [并行] 预分配 {need_mb}MB 通过（{_time.time() - _t0:.2f}s）")
+    _vlog().info(f"  [并行] workers={base}（预算 {need_mb}MB / 可用 {avail_mb}MB）")
     return base