Count the flicker, then remove the four things causing it

"It still flickers sometimes" is not something a fix can be tested against,
so the first change is a counter. Drawing is the one place that knows both
what is on screen and what was built, so it asks: `covered()` compares the
rows in the viewport against the window and records how far short it fell
and which way. That turned a symptom into a number, and the number found
four separate causes -- three of which I would not have guessed, and one of
which I had already "fixed" twice.

  - Opening a session recomputed the window before the scroll container had
    measured anything. `maxValue` is zero then, which reads as the reader
    being at the oldest end, so the window landed a whole transcript away
    from where the session was about to open.
  - A page of history recomputed it from a scroll position one layout out
    of date -- stale by exactly the height of the page that had just
    arrived. The reader's position is now carried across the change as a
    row rather than as a pixel, and resolved through the row that *holds*
    that seq, because a regroup can fold the row it named into another.
  - The window was widened to cover the screen only when it was recomputed,
    which was every two screens of movement. A fling covers a screen in a
    frame or two, so it outran the window and arrived at rows that were
    still spacers. Standing rows up a few per frame made that worse rather
    than causing it: after a seed the built window is two screens wide and
    grows two rows a frame. What is near the screen is now widened every
    frame; only the outer bound is lazy.
  - Both were measured in pixels, and a pixel budget cannot know how many
    rows it covers until the rows have been measured -- which is never, on
    the frame a session opens. The margins are now a number of screens *or*
    a number of rows, whichever is larger.

The recompute moved to the transcript's placement, which is the one moment
both halves are current: the rows have just been measured and so has the
scroll container. Everywhere else it ran could be right about one and stale
about the other. It writes only when the answer changes, so a frame where
nothing moved costs one scan and no recomposition.

Two supporting fixes. `covered()` also repairs, so however the window goes
stale the damage is one frame rather than until the next scroll. And the
scroll position is now keyed per session -- `rememberScrollState()` is not
keyed, so a second session opened without leaving the screen inherited the
first one's offset and, worse for the window, its `maxValue`.

Verified on the emulator: flings up and down, three scroll-and-restore
cycles on a 92-row session and three reopens of a short one -- zero, where
before each reopen cost one to three. Placement stayed at 0.8ms.

Also here: crashes are recorded and travel out through the debug button, so
"it crashes opening that chat" arrives with a stack next time; the report
goes to the log as well as the clipboard, so a session driving the app over
adb can read it; and `trace-draw.sh` captures a labelled frame breakdown,
with a note that it must be run against the phone -- on this emulator two
thirds of a frame is `dequeueBuffer` and Compose's own draw is 0.40ms.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

app/androidApp/src/main/kotlin/com/example/aiapp/SessionScreen.kt

@@ -2,6 +2,7 @@ package com.example.aiapp
 
 import android.os.Build
 import android.os.SystemClock
+import android.util.Log
 import android.widget.Toast
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.PickVisualMediaRequest
@@ -1363,8 +1364,17 @@ fun SessionScreen(settings: ServerSettings, summary: SessionSummary, onBack: ()
                                             " ${expandedGroups.size} groups open",
                                     ),
                                 frames = frames.lines(context.refreshHz()),
+                                crash = lastCrash(context),
                             )
                         context.copyToClipboard("ai-app render report", report)
+                        // Also to the log, so a session driving the app over adb can read the
+                        // same report the button copies. The clipboard is not reachable from a
+                        // shell, and a counter nobody can check from here is a counter that only
+                        // gets checked by asking Iris to press a button and paste.
+                        Log.i("ai-app", report)
+                        // Only once it is somewhere it can be read from, so a copy that never
+                        // happened does not throw the stack away with it.
+                        clearCrash(context)
                         // Emptied by the copy, so pressing it twice measures two separate stretches
                         // of scrolling rather than one and then the same one again.
                         frames.reset()