Hold an open call out of its run without taking one out of a group

Being open did two things to grouping, and only one of them was wanted. It held
a call standing on its own out of the run it belongs to, so a command finishing
behind the card being read no longer shuts it and folds it away mid-sentence.
It also took a call *out* of the group it was already inside, and that is what
made collapsing jump: grouping is what gives a row its identity, so one tap
rebuilt the rows around the finger -- opening a call inside a group split the
group into two pieces with mismatched keys, and closing one replaced three rows
with one, which no anchor survives. Measured at 450px of jump, with the card
that was closed going with it.

So the held-out set is now the screen's, not the transcript's: a call that has
never been drawn inside a group and is open stands out of its run, and a call
that has been in one stays in it whatever the reader does to it. Being inside a
group once is a fact about what the reader has been shown, which is why the
screen is what remembers it.

Checked with ktfmtFormat, compileDebugKotlin, lintDebug and testDebugUnitTest,
and on the emulator against the sandbox: opening a call inside an open group of
six leaves it one group of six and closing it returns every row to the pixel it
came from; a call opened while standing alone survives a reply landing behind
it, and folds back into "Called 3 tools" when it is closed without moving the
rows below it.

PLAN.md

@@ -1157,16 +1157,27 @@ dev-updater (Kotlin 2.4.x, CMP 1.11.x, JDK 21).
    - The transcript rendered from the event stream: markdown, inline images,
      tool cards, question cards.
    - **A run of adjacent tool calls is one collapsed card, except for a call
-     that is still running, open, or last in the transcript** (2026-09-15).
-     What the session is doing right now, did last, or what the reader is
-     looking at is the one thing worth seeing without a heading hiding it.
-     What folds a finished call back into its run is being *overtaken* while
-     closed: anything arriving behind it, a reply included, makes it history,
-     and a session that has run its last command and is composing its answer
-     leaves that command standing until the answer starts. Grouping is a
-     display decision (`groupToolRuns`) and a cut run's pieces are keyed there
-     — the first piece keeps the run's name, since that name is what survives
-     a page of history landing in front of it.
+     that is still running, last in the transcript, or held out of its run by
+     being read** (2026-09-15, corrected 2026-09-16). What the session is
+     doing right now, or did last, is the one thing worth seeing without a
+     heading hiding it. What folds a finished call back into its run is being
+     *overtaken*: anything arriving behind it, a reply included, makes it
+     history — except while somebody has it open, since a card being read is
+     not history to them, and a command finishing behind it used to shut it
+     and fold it away mid-sentence.
+     **Being open only ever holds a call out; it never takes one back out of
+     a group it is already in.** That was tried for a day and is what
+     "collapsing jumps" was: grouping gives a row its identity, so a rule
+     reading the open set both ways let one tap rebuild the rows around the
+     finger — closing a call replaced three rows with one, and no anchor
+     survives a row that has ceased to exist. A call inside an open group is
+     visible where it is and has nothing to gain by moving. The screen is
+     what remembers which calls have been in a group (`everGrouped` feeding
+     `heldOut`), because that is a fact about what the reader has been shown
+     rather than about the transcript. Grouping is otherwise a display
+     decision (`groupToolRuns`) and a cut run's pieces are keyed there — the
+     first piece keeps the run's name, since that name is what survives a
+     page of history landing in front of it.
    - **Anything that is a note *about* the conversation rather than a turn in
      it is closed by default** — a tool call, a peer message, a memory note.
      Open-ness is the screen's, never the card's: a card that remembered for