fix(plugin): StopAll 并行停插件 —— 修关停必然超时被 SIGKILL

## 现象

systemd 每次都报 `State 'stop-sigterm' timed out. Killing.`
进程组里 23 个子进程插件**全退完了**，最后那条 `[homed] stopped`
仍打不出来，然后被 SIGKILL。

## 根因（算出来的，不是猜的）

单个插件的 Stop 最坏预算：
  5s（CallContext plugin.stop）+ 5s（等 exited）+ 2s（Kill 后收割）= 12s
串行停 23 个 ⇒ 23 × 12s = 276s，而 systemd 只给 90s。
⇒ 关停必然超时。线上每一条 stop 记录都是 timed out，无一例外。

## 改法

StopAll 改为并行：取插件快照 + 各自的 SDK 句柄后**立即释放 registry 锁**，
每个插件一个 goroutine，等全部完成再释放共享段。

三处必须小心的点（都是并行化引入的新风险）：

1. **先释放 registry 锁再并行停**。p.Stop() 会触发
   markExited → onExit → ReclaimOwner，那条链要读共享内存段。
   持着锁并行跑，若某插件的 onExit 需要拿 registry 锁（摘通道等）
   就是自死锁。
2. **stop handler 的快照要在清空 sdkRefs 之前取**。handler 挂在
   PluginSDK 上（r.sdkRefs），先清空就再也拿不到了。
3. **单个插件 panic 不带崩关停**（那会让剩下的插件全停不掉），
   也不静默吞（留日志）。

## 判据：5 条 + 3 组变异 + race

- TestStopAllStopsInParallel：8 个插件各 120ms，串行 960ms / 并行 120ms。
  判据直接量耗时，串行实现必然变红（实测串行时 962ms）。
- TestStopAllSurvivesPanickingPlugin：panic 不外冒、其它插件照停、不死锁
  （带 10s 超时，死锁会超时而不是挂住测试）
- TestStopAllFreezesAutoRestart / StopsEachPluginExactlyOnce：
  冻结自动重启、每个插件恰好 Stop 一次（重复会二次释放共享段）
- TestStopAllRunsStopHandlerBeforeStop：handler 必须先于 Stop，
  走真实的 PluginSDK.RegisterStopHandler 路径

变异：退回串行 → 判红并打出实测耗时；去掉 handler 调用 → 顺序判红；
假装并行只清空 → 4 条判红。
`-race` 通过（并行化必须验锁，这是本次改动的头号风险）。

全量 41 包绿。

internal/plugin/registry.go

@@ -707,17 +707,40 @@ func (r *Registry) runOnRemoveHandlers(name string) {
 	}
 }
 
+// stopTarget 是 StopAll 并行化时的一个停止单元：插件本体 + 它的 SDK 句柄。
+type stopTarget struct {
+	plugin sdk.Plugin
+	sdkRef *sdk.PluginSDK
+}
+
 func (r *Registry) StopAll() {
 	// 关停开始即冻结自动重启：否则「Stop 触发退出 → 崩溃判定 → 重新 spawn」
 	// 会在内核正在关停时把子进程又拉起来，段已拆而进程还在，直接 SIGBUS。
 	r.shuttingDown.Store(true)
 
+	// 取插件快照后**立即释放 registry 锁**，再并行停。
+	//
+	// 为何必须并行：串行时最坏耗时 = Σ(每个插件) = 5s(plugin.stop 调用)
+	// + 5s(等退出) + 2s(收割) = 12s；线上有 23 个子进程插件，
+	// 即 276s，而 systemd 只给 90s ⇒ 关停必然 timed out 然后 SIGKILL。
+	// 实测确实每次都超时（线上日志里 23 个插件全退完了，
+	// 最后那条 "[homed] stopped" 仍打不出来）。
+	//
+	// 为何先释放锁：p.Stop() 会触发 markExited → onExit → ReclaimOwner，
+	// 那条链要读共享内存段。持着 registry 锁并行跑，若某插件的 onExit
+	// 回调需要拿 registry 锁（如摘通道），就是自死锁。
 	r.mu.Lock()
-	for _, p := range r.instances {
-		r.runStopHandlers(p.Name())
-		if err := p.Stop(); err != nil {
-			log.Printf("[plugin] stop %s: %v", p.Name(), err)
+	snapshot := make([]sdk.Plugin, len(r.instances))
+	copy(snapshot, r.instances)
+	// stop handler 挂在 PluginSDK 上（r.sdkRefs），必须**在清空 sdkRefs 之前**
+	// 把 handler 跑掉 —— 否则下面并行 goroutine 里就找不到它了。
+	// runStopHandlers 自己不加锁（调用方持锁），这里正是持锁状态。
+	stoppers := make([]stopTarget, 0, len(snapshot))
+	for _, p := range snapshot {
+		if p == nil {
+			continue
 		}
+		stoppers = append(stoppers, stopTarget{plugin: p, sdkRef: r.sdkRefs[p.Name()]})
 	}
 	r.plugins = make(map[string]sdk.Plugin)
 	r.instances = nil
@@ -725,6 +748,30 @@ func (r *Registry) StopAll() {
 	r.sdkRefs = make(map[string]*sdk.PluginSDK)
 	r.mu.Unlock()
 
+	// 并行停：每个插件一个 goroutine，等全部完成。
+	// 单个插件 panic 不带崩整个关停（那会让剩下的插件全停不掉），
+	// 也不静默吞掉（留下日志）。
+	var wg sync.WaitGroup
+	for _, t := range stoppers {
+		wg.Add(1)
+		go func(tg stopTarget) {
+			defer wg.Done()
+			defer func() {
+				if rec := recover(); rec != nil {
+					log.Printf("[plugin] stop %s panic: %v", tg.plugin.Name(), rec)
+				}
+			}()
+			// stop handler（解绑通道等）必须先于 Stop：见 runStopHandlers 注释。
+			if tg.sdkRef != nil {
+				tg.sdkRef.RunStopHandlers()
+			}
+			if err := tg.plugin.Stop(); err != nil {
+				log.Printf("[plugin] stop %s: %v", tg.plugin.Name(), err)
+			}
+		}(t)
+	}
+	wg.Wait()
+
 	// 共享段在全部子进程退出后再释放：插件还持有映射时拆段，
 	// 它们下一次访问就是 SIGBUS。在锁外调用：Close 不需 registry 锁，
 	// 而持锁调它会与 onProcCrash 路径（子进程退出回调）产生锁序风险。