Materialize the trash — store, undo, and the container universe

Phase 2 swaps every consumer: Liveness and its ancestor walk are gone,
replaced by ItemContainer — a UUID set plus the container side it
lives on, presence the whole test, one selection boundary instead of
the old liveness law. Deletion stages by place: board cards move to
the trash at a store-minted head rank, trash-side delete is permanent
behind its confirmation, Delete Immediately skips the trash from
anywhere, lane delete captures the subtree and removes the folder.
Restore has no method at all — moveCards resolves members in either
container, so drag-out and cut-paste are the ordinary moves 13 calls
them, registering ordinary Move steps. The delete inverse moves the
card back to its captured lane and rank; redo replays the captured
trash rank, a value the gesture actually wrote; lane undo recreates
the subtree byte-faithfully in session. Purges register nothing —
where 13's trash section contradicts its own Rules on that, Rules
wins, filed for ruling. Staleness collapsed to present-or-absent: a
container is a path, so a foreign restore fails the delete step's
expectation structurally. Legacy tombstones migrate on the loose-file
tail hook, cards oldest-first so minting above top reproduces the
retired newest-first column, lanes returning live, one folded loss
row naming both directions. Put Back, restoreByDrag,
receiveRestoredCards, TrashEntry, and the kind machinery are deleted;
the trash column renders the container correctly with its full face
rework left to phase 3.

Claude-Session: https://claude.ai/code/session_01SR4XGjmBE16ZUYWpfFHXwY

KanbanTests/RawSourceTests.swift

@@ -423,18 +423,18 @@ struct RawSourceStoreTests {
     func aTombstonedCardIsRefused() throws {
         let fixture = try makeBoard()
         defer { fixture.tearDown() }
-        try BoardWriter.deleteItem(at: fixture.url(cardPath))
+        try fixture.move(cardPath, toTrash: Ident.card1)
         let store = try BoardStore(rootURL: fixture.root)
-        let before = try fixture.indexData(cardPath)
+        let before = try fixture.indexData(".trash/\(Ident.card1)")
         let card = ItemID(rawValue: Ident.card1)
 
-        // 05 ▸ Deletion & lifecycle: "An open raw-source buffer discards instead: its Apply writes
-        // the *whole* pre-tombstone `index.md` and would silently undelete the card — a foreign
-        // delete is never reverted by a stale buffer." The Edit buffer's flush is the opposite rule,
-        // deliberately, which is why the two walks differ (`liveItem` vs `cardBodyTarget`).
+        // 05 ▸ Deletion & lifecycle: "An open raw-source buffer discards instead: its Apply would
+        // write a whole stale `index.md` over the trashed card — a delete is never fought by a stale
+        // buffer." The Edit buffer's flush is the opposite rule, deliberately, which is why the two
+        // walks differ (`boardItem` vs `cardBodyTarget`).
         #expect(store.readCardSource(inCard: card) == .vanished)
         #expect(store.applyCardSource(inCard: card, text: handEditedSource) == .vanished)
-        #expect(try fixture.indexData(cardPath) == before)
+        #expect(try fixture.indexData(".trash/\(Ident.card1)") == before)
     }
 
     @Test("A card that is not in the board at all is vanished too")