Hold the transcript still while somebody is reading further back

Two separate defects, both of which moved the list under the reader.

The first: a row that grows drags the view toward the newest end. The
list is laid out from the bottom, so it anchors on the first visible
item's *bottom* edge -- and a reply streaming in extends that row
upwards, pushing everything already on screen with it. Measured against
a reply streamed in four hundred pieces: scrolling back one screen and
waiting six seconds ended at the very bottom, forty lines further on
than where it was left. So the transcript now only changes while the
reader is at the newest end; anything arriving before then waits in
order and lands when they return. Status, tokens and the model still
update live, because none of those are drawn in the list and freezing
them would trade a jumping transcript for a status row that lies.

The second: every markdown row was measured at nothing before it was
measured at its real height. The renderer's `content: String` overload
parses in a coroutine and draws an empty loading slot until it finishes,
so a row composes with no height and springs open a frame later. Seen
with five replies on screen at once, all blank, the whole conversation
shrunk to a single screen. Parsing in the composition costs a few
milliseconds on the main thread and is worth it: no scroll anchoring can
survive a row that lies about its height first.

`/stream N` in the echo driver is what made the first one reproducible
-- `/slow` emits a line a second, and the growth has to be continuous
for the anchor row to drag.

Verified on the emulator: scrolled back through a whole 400-piece
stream, the transcript region is pixel-identical across ten seconds
while the status row goes from working to idle; returning to the bottom
brings the backlog in one go. Checked the tool-call rig too, which this
change had no reason to touch -- paging back still works and every group
still reads "Called 8 tools".

server/src/session/echo.rs

@@ -25,6 +25,9 @@
 //! This is exactly the event vocabulary the real drivers produce, so a UI
 //! that renders echo sessions correctly renders the real thing.
 //!
+//! - `/stream N` -- one long answer in N small pieces, 50ms apart: the
+//!   shape a real model's reply arrives in, and the one where the row a
+//!   reader is anchored to is the row that keeps changing height.
 //! - `/mixed N` -- N beats of an interleaved transcript: paragraphs of
 //!   different lengths, single tool calls, runs of adjacent ones, images
 //!   and a peer message. Rows of every shape and height the app draws, in
@@ -326,6 +329,9 @@ impl EchoDriver {
         // rather than trusted: this is a test affordance, and a session
         // pinned running for an hour by a typo is a worse outcome than a
         // short wait.
+        let stream = text
+            .strip_prefix("/stream")
+            .map(|rest| rest.trim().parse::<usize>().unwrap_or(400).clamp(1, 4000));
         let mixed = text
             .strip_prefix("/mixed")
             .map(|rest| rest.trim().parse::<usize>().unwrap_or(12).clamp(1, 400));
@@ -410,6 +416,23 @@ impl EchoDriver {
                 return;
             }
 
+            // One long answer arriving in small pieces, which is what a real
+            // model does and what `/slow` does not: `/slow` emits a line a
+            // second, so its message grows in steps a reader can watch one
+            // at a time. A jump caused by the *anchor row itself* changing
+            // height needs growth that is continuous.
+            if let Some(pieces) = stream {
+                for i in 0..pieces {
+                    let len = 3 + (i * 7) % 14;
+                    send(Event::AssistantText {
+                        delta: format!("{i}{} ", "x".repeat(len)),
+                    });
+                    tokio::time::sleep(Duration::from_millis(50)).await;
+                }
+                finish();
+                return;
+            }
+
             if let Some(beats) = mixed {
                 for beat in 1..=beats {
                     write_beat(&sink, &dir, beat).await;