Take a rotated vault's contents onto the new key as well

Rotating a vault re-keyed the vault and not its contents, which was the deal
struck last time: everything already stored stayed sealed under the generation it
was written with, every remaining member kept the older keys, and the guarantee
was narrowed to "nothing written from now on". That left one gap worth closing —
somebody who walked off with the old key could still open old ciphertext they
later got hold of — and the reason it was safe to defer is the reason it was
cheap to add. A vault at mixed generations reads perfectly well, so the pass that
moves items across can stop half way and be run again.

VaultResealer walks the vault and rewrites each item as an ordinary upsert
against the version the server holds. It never decodes the plaintext: an item is
opened and the same bytes are sealed again under a fresh data key, so an item
written by a newer client crosses a rotation untouched rather than being
re-encoded through this build's codec and quietly losing the fields this build
has no concept of. It also means nothing in the pass knows what an item is, which
is why one loop covers every type including the ones added after it. A conflict
is counted and skipped rather than merged — there is nothing to merge, since no
content changes — and the next pass picks the item up at the version the other
client left.

The half that a pass over stored items cannot see is a change queued before the
rotation and pushed after it, which would put a brand-new item into the vault
under the key the person who just left still holds. So the push path re-seals a
stale payload as it dispatches it, writing the revision back to the outbox first
so that a retry sends the same bytes rather than a fresh envelope. Between the
two, nothing reaches the server under a superseded generation at all. Queued
items are therefore deliberately left alone by the pass: rewriting one there
would overwrite the user's unpushed work with the version the server holds, which
is the one thing a re-keying pass must never do.

Removal runs it last, after a sync — a mirror that is behind produces a batch of
conflicts instead of a re-sealed vault — and the status line distinguishes the two
guarantees, because they are not the same: a vault fully re-sealed is closed to
the person who left, and one with items outstanding is closed only to what
happens next.

Six tests, and three mutations run against them: making the re-seal return the
payload unchanged fails five of the six, making the push path skip re-sealing
fails the queued-edit test and only that one, and counting conflicts as applied
fails the write-elsewhere test. One of the six was wrong before it was right — it
modelled a third-party write by re-pushing an existing payload at a bumped
version, which no real client would do, and it took reading the AAD to see that
the test was lying rather than the code.

docs/crypto.md

@@ -229,9 +229,13 @@ This is the load-bearing structural choice. Because every wrap protects the *sam
 > at once and every read chooses the key its item names. That is why a member's grants for earlier
 > generations are kept rather than revoked, why `VaultSummary` serves all of them, and why sharing
 > issues one grant per generation held: a client holding only the newest key would read the vault's
-> whole history as tag failures. Re-sealing stored items under the new key is a separate pass and is
-> not yet built — see [ADR 0010](adr/0010-vault-key-rotation.md) for the guarantee this does and does
-> not buy.
+> whole history as tag failures.
+>
+> Moving those items onto the new key is a **separate pass** (`VaultResealer`), run last and resumable
+> because a vault at mixed generations is readable. It opens each item and seals the same plaintext
+> again under a fresh data key — the envelope is re-made rather than only the wrap, because the AAD
+> binds `keyGeneration` into both. The plaintext is never decoded, so an item written by a newer client
+> crosses a rotation untouched. See [ADR 0010](adr/0010-vault-key-rotation.md).
 
 Per-item keys wrapped *to individual users* — which is what would make per-item ACLs
 cryptographic rather than server-enforced — are deferred to M5. The `content_key_id` column