Select any of the transcript, and take a queued message back

Two things a reader could not do to what is on screen.

**Selection.** Nothing in the transcript was selectable at all, so a
command, a path or an error message could be read and not copied. One
`SelectionContainer` around the whole list rather than one per row: a
transcript is one body of text to a reader, and a selection has to be able
to run from a reply into the tool output under it. Per row it also could
not, and whatever was drawn without a container would have been silently
unselectable -- a state nothing on screen reports. Rows keep their tap
handlers; checked on the emulator that expanding a tool call, scrolling and
flinging are all unaffected, since a selection is a long press.

**Taking a message back.** A message sent into a running turn sits as a
bubble waiting to be read, and there was no way to change your mind: it is
tappable now, and the server answers `POST /sessions/{id}/unqueue`.

The answer has three states, and the middle one is the point. Claude's
driver writes a steer into the CLI's stdin the instant it arrives -- that
is what makes it reach the model at the next tool boundary rather than at
the end of the turn, and it was measured -- so the line is already gone and
`AlreadySent` is the only honest answer it can give. Holding the write
until a boundary would make the drop real and cost a steer one model call,
which is the latency the immediate write exists to remove; rejected on that
trade, with the reasoning in PLAN.md. The refusal is drawn on the bubble
that was pressed rather than in the error row under the header, a screen
away from it.

Where a driver really does hold its queue -- echo today -- the message goes
for good, and it goes as an `Event::MessageDropped` rather than as a return
value: every device watching the session loses the bubble, and a phone that
reconnects and replays the `messageQueued` does not put back one that was
cancelled with nothing left to resolve it.

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

@@ -53,6 +53,16 @@ sealed class SessionEvent {
     data class MessageQueued(val id: String, val text: String, val images: List<String>) :
         SessionEvent()
 
+    /**
+     * A queued message taken back before the session read it.
+     *
+     * Recorded by the server for the same reason [MessageQueued] is: a phone that reconnects
+     * replays both, and without this one it would put back a bubble for a message that is never
+     * coming -- with nothing left to resolve it, since the [UserMessage] that normally does is
+     * exactly what was cancelled.
+     */
+    data class MessageDropped(val id: String) : SessionEvent()
+
     data class AssistantText(val delta: String) : SessionEvent()
 
     data class ToolStart(val id: String, val tool: String, val input: String) : SessionEvent()
@@ -183,6 +193,7 @@ fun parseSeqEvent(json: String): SeqEvent {
                     body.getString("text"),
                     body.stringList("images"),
                 )
+            "messageDropped" -> SessionEvent.MessageDropped(body.getString("id"))
             "assistantText" -> SessionEvent.AssistantText(body.getString("delta"))
             "toolStart" ->
                 SessionEvent.ToolStart(