test: give the log level and ownership rules real enforcement

两条"确证的假绿"(独立验证发现):

① 设计 §3.2 的"配置级致命发 error 而非 warning"没有执法点:
   `captured_warnings` fixture 挂在 level="WARNING",ERROR 与 WARNING
   同池,且 tracker 自己那条 WARNING 文案就含"重启"——把 recorder 的
   `logger.error` 整块删掉,原用例照样绿。新增 `captured_logs` fixture
   连级别一起捕获,三处补上级别断言。

   顺带消掉实现与设计的偏离: 原实现同时发 1 条 ERROR(recorder)+ 1 条
   语义重复的 WARNING(tracker)。级别决策收敛到 tracker 一处(fatal →
   error,其余 → warning),recorder 侧不再另发,SQLite 侧同时受益。

② 所有权判定的 `is None` / `is not None` 纪律(设计 §3.4)零覆盖:
   所有假件都是 truthy,把工厂改回 `limiter or _build_limiter(...)`
   全套件照样绿。补 `_FalsyClosable`(`__bool__` 返 False)与三个工厂
   各一条用例: 注入 falsy 后端时工厂不得自建、`_owns_*` 为 False、
   `aclose` 不得关它。

tests/unit/test_client.py

@@ -585,10 +585,27 @@ class _SyncClosable:
         self.closed += 1
 
 
+class _FalsyClosable(_Closable):
+    """`bool()` 为假的组件(空容器形态的后端就长这样)。
+
+    所有权判定必须写 `is None` / `is not None`,不得写 `or`(设计 §3.4,ARCH §4.5
+    细则 2): 写 `or` 时注入这样一个后端会**悄悄走自建分支**,而所有权标志按
+    `is None` 判成 False——于是既没用上注入的那个,自建的那个又没人关,正是本
+    issue 要修的泄漏原地复活。判定与标志一漂移,两个 bug 一起回来。
+    """
+
+    def __bool__(self):
+        return False
+
+
 def _parts(*names):
     return {name: _Closable() for name in names}
 
 
+def _falsy_parts(*names):
+    return {name: _FalsyClosable() for name in names}
+
+
 def _patch_builders(monkeypatch, built, *, transport_path):
     """把工厂的自建点换成可计数假件;transport 无注入入口,故恒自建。"""
     monkeypatch.setattr(transport_path, lambda **kwargs: built["transport"])
@@ -654,6 +671,38 @@ class TestGatewayClientOwnership:
         assert all(part.closed == 0 for part in injected.values())
         assert built["transport"].closed == 1  # 工厂恒自建 transport,归 client
 
+    async def test_falsy_injected_components_are_still_injected(self, monkeypatch):
+        """`is not None` 是所有权判定成立的**必要条件**,不是风格偏好(设计 §3.4)。
+
+        改回 `or` 时: 工厂拿自建件顶掉注入件(下游以为在共享,其实各跑各的),
+        且自建件的 `_owns_*` 仍是 False —— redis 客户端就地泄漏。
+        """
+        built = _parts("transport", "telemetry", "cache", "limiter", "breaker")
+        _patch_builders(monkeypatch, built, transport_path=self._GATEWAY_TRANSPORT)
+        injected = _falsy_parts("telemetry", "cache", "limiter", "breaker")
+        client = GatewayClient.from_settings(
+            GatewaySettings.from_env("LLM", env=_CACHE_ENV),
+            limiter=injected["limiter"],
+            breaker=injected["breaker"],
+            cache=injected["cache"],
+            telemetry=injected["telemetry"],
+        )
+        assert client._limiter_backend is injected["limiter"]
+        assert client._breaker_backend is injected["breaker"]
+        assert client._cache is injected["cache"]
+        assert client._telemetry is injected["telemetry"]
+        owns = (client._owns_limiter, client._owns_breaker, client._owns_cache)
+        assert owns == (False, False, False) and client._owns_telemetry is False
+        await client.aclose()
+        assert all(part.closed == 0 for part in injected.values())
+        # 自建件根本不该被造出来更不该被关;只有恒自建的 transport 归 client
+        assert [built[name].closed for name in ("telemetry", "cache", "limiter", "breaker")] == [
+            0,
+            0,
+            0,
+            0,
+        ]
+
     async def test_aclose_is_idempotent(self, monkeypatch):
         built = _parts("transport", "telemetry", "cache", "limiter", "breaker")
         _patch_builders(monkeypatch, built, transport_path=self._GATEWAY_TRANSPORT)
@@ -746,6 +795,39 @@ class TestEmbeddingClientOwnership:
         assert all(part.closed == 0 for part in injected.values())
         assert built["transport"].closed == 1
 
+    async def test_falsy_injected_components_are_still_injected(self, monkeypatch):
+        """三处工厂各写一遍 `is not None`,就是三处各有一次漂移回 `or` 的机会。"""
+        from polygateway.config import EmbeddingSettings
+        from polygateway.embedding import EmbeddingClient
+
+        built = _parts("transport", "telemetry", "limiter", "breaker")
+        _patch_builders(
+            monkeypatch,
+            built,
+            transport_path="polygateway.transports.openai_compat.OpenAICompatTransport",
+        )
+        injected = _falsy_parts("telemetry", "limiter", "breaker")
+        settings = EmbeddingSettings(
+            gateway=GatewaySettings.from_env("LLM", env=_ENV), batch_size=2
+        )
+        client = EmbeddingClient.from_settings(
+            settings,
+            limiter=injected["limiter"],
+            breaker=injected["breaker"],
+            telemetry=injected["telemetry"],
+        )
+        assert client._limiter_backend is injected["limiter"]
+        assert client._breaker_backend is injected["breaker"]
+        assert client._telemetry is injected["telemetry"]
+        assert (client._owns_limiter, client._owns_breaker, client._owns_telemetry) == (
+            False,
+            False,
+            False,
+        )
+        await client.aclose()
+        assert all(part.closed == 0 for part in injected.values())
+        assert [built[name].closed for name in ("telemetry", "limiter", "breaker")] == [0, 0, 0]
+
 
 def _ocr_client(**overrides):
     from polygateway.ocr import OcrClient
@@ -811,6 +893,35 @@ class TestOcrClientOwnership:
         assert all(part.closed == 0 for part in injected.values())
         assert built["transport"].closed == 1
 
+    async def test_falsy_injected_components_are_still_injected(self, monkeypatch):
+        from polygateway.config import OcrSettings
+        from polygateway.ocr import OcrClient
+
+        built = _parts("transport", "telemetry", "limiter", "breaker")
+        _patch_builders(
+            monkeypatch,
+            built,
+            transport_path="polygateway.transports.monkey_ocr.MonkeyOcrTransport",
+        )
+        injected = _falsy_parts("telemetry", "limiter", "breaker")
+        client = OcrClient.from_settings(
+            OcrSettings.from_env("OCR", env=dict(_OCR_ENV)),
+            limiter=injected["limiter"],
+            breaker=injected["breaker"],
+            telemetry=injected["telemetry"],
+        )
+        assert client._limiter_backend is injected["limiter"]
+        assert client._breaker_backend is injected["breaker"]
+        assert client._telemetry is injected["telemetry"]
+        assert (client._owns_limiter, client._owns_breaker, client._owns_telemetry) == (
+            False,
+            False,
+            False,
+        )
+        await client.aclose()
+        assert all(part.closed == 0 for part in injected.values())
+        assert [built[name].closed for name in ("telemetry", "limiter", "breaker")] == [0, 0, 0]
+
 
 class TestRedisCacheOwnership:
     """组件内部自建的连接归组件自己;照抄 RedisLimiter._owns_client 的正确先例。"""