fix(m165): forget 之后让自更新也换引擎（复审 P2-1）+ 卡口计数与端到端守卫

复审 P2-1（采「修法 1」，不是只改措辞）：`shared::forget` 只让登记处不再持有
那一份，换不掉自更新 `Factory` 里常驻的 Arc —— 于是「重新检测地区」对更新路径
不生效，直到重启。现在设置动作会把 Factory 一起重建。

- presenter/update_state: `Runtime::rebuild_factory` + `CoreHost::refresh_update_factory`；
  只换 factory，不动 view/inflight（在飞的 Job 派发时已克隆走装配，重建不打断它）
- presenter/dispatch: `SetSetting` 成功且键是「重新检测地区」时调 refresh
- presenter/engine: `DETECT_REGION_ACTION` 常量（设置页行 id / set 分派 / dispatch
  判断共用）；放这里而不是 settings.rs 是因为后者已到 400 行红线
- core/shared: 文档改准 —— forget 的范围是「登记处不再持有」，长命持有者必须自己重建；
  记账从 `engine_for` 移到 `DownloadEngine::new` 这个卡口（分两把锁，避免自锁），
  于是 `constructions` 连绕过登记处另造引擎的调用点也统得住

守卫（都做了变异实证）：
- update_tests::detect_region_rebuilds_the_update_factory_engine：走真实命令路径
  `AppCommand::SetSetting` → 断言 Factory 换了引擎且指向登记处当前实例；变异（删掉
  dispatch 里那句 refresh）→ 红在 Arc::ptr_eq
- update_tests::rebuilding_the_factory_does_not_touch_a_running_job：重建不清
  inflight、不改快照，在飞 Job 仍能跑完
- addon/http::tests::three_host_request_paths_share_one_engine：连走三条真实宿主路径
  （Modrinth 元数据 GET / CF 带 header GET / Java 页渲染）后 constructions == 1；
  变异（让 get_via_engine 自己造引擎）→ 红，left:2 right:1

顺带修：settings.rs 在上一提交被推到 403 行、engine.rs 401 行，两者都超
guards.yml 的 file-size 红线（>400 直接失败）。现在 settings.rs 400 / engine.rs 399，
全仓 `*.rs` 复跑「>400」扫描无输出。

验证：core lib 608 过、5 个 download 集成 target 42 过、presenter lib 270 过、
clippy --all-targets 干净、fmt 干净。真站点仍未打（见报告「没验的部分」）。

crates/presenter/src/host/addon/http.rs

@@ -126,3 +126,114 @@ pub(super) fn encode(raw: &str) -> String {
     }
     out
 }
+
+#[cfg(test)]
+mod tests {
+    use std::io::{Read as _, Write as _};
+    use std::net::TcpListener;
+    use std::time::Duration;
+
+    use unlucky_core::download::shared;
+
+    use super::get;
+    use crate::host::env::HostEnv;
+
+    /// 离线回环 HTTP 服务：只答固定 JSON，数「处理了几条请求 / 接了几条连接」。
+    ///
+    /// 用 127.0.0.1 而不是真站点：**单测不许打公网**（CI 没网，也不该有）。
+    fn loopback(expected_requests: usize) -> (String, std::sync::mpsc::Receiver<(usize, usize)>) {
+        let listener = TcpListener::bind("127.0.0.1:0").expect("绑定回环端口");
+        let addr = listener.local_addr().expect("取端口");
+        let (tx, rx) = std::sync::mpsc::channel();
+        std::thread::spawn(move || {
+            let mut conns = 0usize;
+            let mut requests = 0usize;
+            while requests < expected_requests {
+                let Ok((mut socket, _)) = listener.accept() else {
+                    break;
+                };
+                conns += 1;
+                let _ = socket.set_read_timeout(Some(Duration::from_secs(5)));
+                let mut seen = Vec::new();
+                loop {
+                    let mut chunk = [0u8; 1024];
+                    match socket.read(&mut chunk) {
+                        Ok(0) | Err(_) => break,
+                        Ok(read) => seen.extend_from_slice(&chunk[..read]),
+                    }
+                    if !seen.windows(4).any(|window| window == b"\r\n\r\n") {
+                        continue;
+                    }
+                    requests += 1;
+                    let body = br#"{"ok":true}"#;
+                    let head = format!(
+                        "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n",
+                        body.len()
+                    );
+                    if socket.write_all(head.as_bytes()).is_err() || socket.write_all(body).is_err()
+                    {
+                        break;
+                    }
+                    seen.clear();
+                    if requests >= expected_requests {
+                        let _ = tx.send((conns, requests));
+                        return;
+                    }
+                }
+            }
+            let _ = tx.send((conns, requests));
+        });
+        (format!("http://{addr}/v2/search"), rx)
+    }
+
+    /// 一个只用来放缓存根的临时数据根（`<root>/.ULL/cache`）。
+    fn data_root(tag: &str) -> std::path::PathBuf {
+        static SEQ: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
+        let seq = SEQ.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+        let dir = std::env::temp_dir().join(format!("ull-http-{tag}-{}-{seq}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(dir.join(".ULL").join("cache")).expect("建缓存根");
+        dir
+    }
+
+    /// **端到端守卫（M165 复审备注 2）**：连走三条真实宿主请求路径，只该构造一个引擎。
+    ///
+    /// 为什么不满足于「再断言一次 `engine()` 复用」：那种断言只钉漏斗本身——将来谁在调用点
+    /// 自己 `DownloadEngine::new`，它照旧全绿。这里数的是 `shared::constructions`，而记账卡在
+    /// `DownloadEngine::new` 这个卡口上（与谁造的无关），所以只要有一条路径另造引擎就会红。
+    ///
+    /// 三条路径：
+    /// 1. [`get`] 无 header = 内容库的 Modrinth 元数据 GET（走 `engine.download_bytes`）；
+    /// 2. [`get`] 带 header = CurseForge 那条（走 `engine.client()`，另一条机制）；
+    /// 3. `host::java::vendors` = Java 页渲染（走 `domestic()`，非 HTTP 的漏斗消费者）。
+    ///
+    /// 没走 `versions` 清单：它的地址是写死的 launchermeta，单测里要么打真网、要么吃满连接超时
+    /// —— 那正是「测试里不该发生的事」，所以选了同样真实但完全离线的三条。
+    #[test]
+    fn three_host_request_paths_share_one_engine() {
+        let dir = data_root("paths");
+        let env = HostEnv::at_root(&dir);
+        let cache_root = env.layout.cache();
+        let (url, counts) = loopback(2);
+
+        let without_headers = get(&env, &url, &[]).expect("Modrinth 元数据 GET");
+        let with_headers = get(&env, &url, &[("x-api-key", "test-key")]).expect("CF 带 header GET");
+        let vendors = crate::host::java::vendors(&env, &[]);
+
+        assert_eq!(
+            without_headers, with_headers,
+            "两条路径读的是同一份回环响应"
+        );
+        assert!(!vendors.is_empty(), "Java 页应有发行版行");
+        let (_, requests) = counts
+            .recv_timeout(Duration::from_secs(10))
+            .expect("回环服务应报告计数");
+        assert_eq!(requests, 2, "两条 HTTP 路径各发一条请求");
+        assert_eq!(
+            shared::constructions(&cache_root),
+            1,
+            "三条宿主请求路径必须共用同一个引擎（谁绕过漏斗另造一个，这条就红）"
+        );
+        std::fs::remove_dir_all(&dir).ok();
+    }
+}