fix(ingest): address review round 3 + SonarCloud reliability gate

- tests: make the transient-backoff progression assertion load-independent by
  bracketing the get_retry_decision call with before/after timestamps instead of
  measuring against a second datetime.now() (no freezegun dependency).
- tests: use pytest.approx for the ingest-queue-depth gauge assertions —
  SonarCloud python:S1244 (float == ) was a MAJOR reliability finding that
  tripped the new_reliability_rating quality gate.
- processor: tighten the EscalateError lazy-bind comment (file processing already
  imports the document stack via get_registry; the gating only spares the
  delete / text-doc paths and module-load time).

Deck #323.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

tests/unit/vector/test_tiered_escalation_strategy.py

@@ -91,16 +91,22 @@ class TestTieredEscalationStrategy:
 
     def test_transient_backoff_progression(self):
         # min(4 * 2**(attempts-1), 300): 4, 8, 16, ... capped at 300s.
+        # procrastinate sets retry_at = utcnow() + wait at call time. Bracketing
+        # the call with before/after makes the assertion exact and independent of
+        # runner load: with before <= call_now <= after, we have
+        #   (retry_at - after) <= wait <= (retry_at - before).
         strat = self._strategy(max_transient=100)
         for attempts, expected in [(1, 4), (2, 8), (3, 16), (4, 32), (20, 300)]:
+            before = datetime.now(timezone.utc)
             decision = strat.get_retry_decision(
                 exception=httpx.ConnectError("x"), job=_job(attempts=attempts)
             )
+            after = datetime.now(timezone.utc)
             assert decision is not None and decision.retry_at is not None
-            delta = (decision.retry_at - datetime.now(timezone.utc)).total_seconds()
-            # retry_at = now + wait; allow a small window for execution time.
-            assert expected - 2 <= delta <= expected + 1, (
-                f"attempts={attempts}: delta={delta:.2f}s, expected≈{expected}s"
+            lo = (decision.retry_at - after).total_seconds()
+            hi = (decision.retry_at - before).total_seconds()
+            assert lo <= expected <= hi, (
+                f"attempts={attempts}: expected={expected}s not in [{lo:.3f}, {hi:.3f}]"
             )
 
     def test_transient_gives_up_over_cap(self):