test(manifest): update is_recovered comments to reflect Round-7 lexical guard

Round 8 — addresses Copilot review comment on tests/integrations/test_manifest.py:362.

After Round-7 (1dbf0c2), is_recovered() rejects absolute paths and '..' segments
up front via a lexical guard, returning False without calling _validate_rel_path
at all. The test comments still described the prior "_validate_rel_path raises;
we catch" code path, which is misleading for readers.

Updated comments in both:
  - test_is_recovered_absolute_path_returns_false (Copilot's exact target)
  - test_is_recovered_escaping_path_returns_false (same comment-class issue;
    fixed preemptively to avoid a Round-9 finding on the same drift)

Pure documentation change. Test assertions and behavior unchanged; all manifest
tests still green.

Author: eldar702

tests/integrations/test_manifest.py

@@ -356,10 +356,12 @@ def test_load_rejects_non_list_recovered_files(self, tmp_path):
 
     def test_is_recovered_absolute_path_returns_false(self, tmp_path):
         # Copilot round-5 finding: passing an absolute path silently returned
-        # False because the stored keys are relative POSIX strings. Now the
-        # call normalizes through ``_validate_rel_path`` which raises on
-        # absolute inputs; we catch and return False so query semantics stay
-        # exception-free.
+        # False because the stored keys are relative POSIX strings. Round-7
+        # made this explicit: ``is_recovered`` now rejects absolute paths
+        # up front via a lexical ``rel.is_absolute()`` guard and returns
+        # False without calling ``_validate_rel_path`` at all — matching
+        # ``record_existing``'s canonical-key guard so the two methods
+        # agree on which inputs can ever be stored keys.
         (tmp_path / "f.txt").write_text("x", encoding="utf-8")
         m = IntegrationManifest("test", tmp_path)
         m.record_existing("f.txt", recovered=True)
@@ -368,9 +370,14 @@ def test_is_recovered_absolute_path_returns_false(self, tmp_path):
         assert m.is_recovered(abs_input) is False
 
     def test_is_recovered_escaping_path_returns_false(self, tmp_path):
-        # A relative path that resolves outside project_root cannot have been
-        # recorded; ``_validate_rel_path`` raises and ``is_recovered`` returns
-        # False rather than letting the ValueError propagate.
+        # A relative path containing ``..`` segments cannot be a stored key:
+        # Round-7 added the same lexical ``".." in rel.parts`` guard to
+        # ``is_recovered`` that ``record_existing`` already enforces, so the
+        # method returns False immediately without reaching
+        # ``_validate_rel_path``. The try/except around ``_validate_rel_path``
+        # remains as defense-in-depth for paths that pass the lexical guard
+        # but still resolve outside the project root via a symlinked
+        # ancestor.
         m = IntegrationManifest("test", tmp_path)
         # Don't record anything — the path is impossible to record anyway.
         assert m.is_recovered("../escape.txt") is False