Mark the story with a node, not with a count

The memory bank and the story summary each kept a cursor: how many story
actions they had already covered. A count is a position in a list, and this
list moves — delete an action in front of the mark and every later one slides
down a slot, so the mark now covers one it has never read. All the cursor
bookkeeping existed to patch that up.

Both marks are now (branch_id, depth): the node up to and including which the
work is done. A depth is a coordinate along a path, not an offset into a list,
so nothing in front of it can move it. That deletes rather than rewrites
`position_of_index`, `note_action_removed`, `_rewind_cursors_to_index`,
`prune_dangling_memories` and the every-pass clamp in `run_post_turn`.

A memory hangs off the node its block ends on, so a fork inherits its
ancestors' memories without copying any, and retrieval selects through the
branch clause over the *whole* lineage — recall is long-range by definition and
cannot be windowed. Measured: 1,807 B on a story forked twenty times against
1,823 B on a flat one of the same length.

Migrations 53-56 translate the old counts into nodes. They rewrite `adventures`
and not `actions`, so this one needs no VACUUM FULL.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017Dvvqn9ZDR4ixeFPHNbww7

backend/app/tree.py

@@ -131,6 +131,24 @@ def place_memory(
     return branch
 
 
+def attach_memory(memory: models.Memory, node: models.Action) -> None:
+    """Hang a memory off the node it was derived from.
+
+    The general rule, of which the memory bank is the first instance: anything
+    derived from the story attaches to the node that produced it, and is then
+    visible from exactly the paths that node is on. A fork inherits its
+    ancestors' memories because it inherits their nodes — nothing is copied and
+    nothing is recreated — and a memory made on a sibling is invisible here
+    because that node is not on this path.
+
+    Not `place_memory`: this takes the branch from the *node*, which is not
+    always the head. A block of story can end before the fork the current
+    branch was made at, and the memory belongs where the ground is.
+    """
+    memory.branch_id = node.branch_id
+    memory.depth = node.depth
+
+
 def place_new_nodes(session: Session) -> None:
     """Place every unplaced node about to be inserted. Runs on every flush.