fix(backup): carry note_supersessions — the coverage guard caught the omission

CI failed on 45c6b1c. `tests/test_services_backup.py` asserts every table is
either in `_BACKED_UP` or explicitly in `_NOT_INCLUDED`, and the new table was
in neither.

That guard exists for exactly this: a new table gets a model and a migration —
both of which fail loudly if wrong — and then silently never gets a backup
section. No error, no warning, and a restore that reports success. Its comment
says it was written to "stop the seventh" table slipping through. This was the
seventh.

Supersession claims are backed up rather than excluded because they are a
JUDGEMENT. Someone decided this note replaced that one, and nothing in either
note's text records the decision. Lose them and a restored corpus silently
returns to ranking stale material alongside current material — with no symptom
that says why.

Scoping differs by backup kind, deliberately. A whole-instance export takes
every row. A single-user export takes only claims where BOTH ends are that
user's notes: a claim spanning out to someone else's record cannot be restored
into a single-user import, since the far id is not in the map, so exporting it
would write a row that silently vanishes on the way back in.

Restore maps both ids and skips the row unless both resolve. A claim is about a
PAIR — half of one is not a weaker claim, it is a dangling row pointing at
whatever note holds that id next. Guarded by `data.get` like every post-v2
section, so v5 and older payloads restore cleanly without it.

BACKUP_VERSION 5 -> 6, and the version test moved with it. A payload section
added without moving the version produces backups that are structurally
different and indistinguishable by inspection.

Refs #278

tests/test_services_backup.py

@@ -13,8 +13,11 @@ import pytest
 from scribe.services import backup
 
 
-def test_backup_version_is_v5():
-    assert backup.BACKUP_VERSION == 5
+def test_backup_version_is_v6():
+    """v6 added note_supersessions (#278). The bump is the point of the test —
+    a payload section added without moving the version produces backups that
+    are structurally different and indistinguishable by inspection."""
+    assert backup.BACKUP_VERSION == 6
 
 
 def test_not_included_lists_the_known_gaps():
@@ -102,11 +105,26 @@ async def test_export_full_backup_contains_every_declared_section():
     assert out["version"] == backup.BACKUP_VERSION
     assert out["scope"] == "full"
     assert "api_keys" in out["_not_included"]
-    # The sections v2 silently dropped, plus the six v5 added (empty here).
+    # The sections v2 silently dropped, the six v5 added, and v6's
+    # note_supersessions (all empty here).
     for key in ("rulebooks", "rulebook_topics", "rules",
                 "rulebook_subscriptions", "rule_suppressions",
                 "topic_suppressions",
                 "systems", "record_systems", "design_systems",
-                "design_tokens", "note_usage_events", "repo_bindings"):
+                "design_tokens", "note_usage_events", "repo_bindings",
+                "note_supersessions"):
         assert key in out, f"missing export section: {key}"
         assert out[key] == []
+
+
+def test_supersession_rows_serialise_the_pair():
+    """The row builder is a plain function precisely so it can be tested with
+    no database — same reason as the other v5/v6 builders."""
+    class _Row:
+        def __init__(self, a, b):
+            self.superseder_id, self.superseded_id = a, b
+
+    assert backup._note_supersession_rows([_Row(9, 4), _Row(9, 5)]) == [
+        {"superseder_id": 9, "superseded_id": 4},
+        {"superseder_id": 9, "superseded_id": 5},
+    ]