Render markdown, and stop wiping messages still waiting to be read

Two things, both about the transcript telling the truth about itself.

Markdown is rendered rather than shown as its source. The parsing is
mikepenz/multiplatform-markdown-renderer, not something written here:
markdown is somebody else's specification, and a hand-written subset of
one disagrees with it at the edges, which is where the bug reports come
from. `Markdown.kt` is only the mapping onto this app's palette, so code,
links and rules take the Catppuccin values the rest of the app uses
rather than the renderer's defaults.

The queued-message list was cleared wholesale whenever a turn ended. But
the backend holds a queue of its own and takes one message per turn, so a
turn ending is precisely the moment the *rest* are still waiting -- the
bubbles vanished while the messages were on their way, which reads as
everything after the first having been dropped. Now a held message
leaves the list exactly two ways: the session reads it, which arrives as
a UserMessage, or its send failed and there is nothing to wait for.

Measured first, because the report was that the backend dropped them:
three messages sent behind one long turn were all delivered in order
(ONE, TWO, THREE) against current main, so the loss was in the display.

Verified on the emulator: headings, emphasis, inline code, nested lists,
a quote bar, a fenced block, a rule and a link all render, and the three
queued messages sit through their turn.

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

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

@@ -372,10 +372,6 @@ fun SessionScreen(
             }
     }
 
-    // A send that never came back cannot stay outstanding forever; the
-    // turn ending is the latest moment it could still have been in flight.
-    LaunchedEffect(running) { if (!running) queued = emptyList() }
-
     LaunchedEffect(summary.setupName, summary.provider) {
         offeredModels =
             try {
@@ -394,13 +390,14 @@ fun SessionScreen(
             }
     }
 
-    fun act(action: () -> Unit) {
+    fun act(onFailure: () -> Unit = {}, action: () -> Unit) {
         scope.launch {
             try {
                 withContext(Dispatchers.IO) { action() }
                 actionError = null
             } catch (e: ApiException) {
                 actionError = e.message
+                onFailure()
             }
         }
     }
@@ -412,7 +409,17 @@ fun SessionScreen(
         input = ""
         pendingAttachments = emptyList()
         if (running && text.isNotEmpty()) queued = queued + text
-        act { sendMessage(settings, summary.id, text, attachments) }
+        // A held message leaves this list exactly two ways: the session
+        // reads it, which comes back as a UserMessage (see `apply`), or the
+        // send itself failed and there is nothing to wait for. Clearing the
+        // whole list when a turn ended was neither -- the server holds a
+        // queue of its own and takes one message per turn, so ending a turn
+        // is precisely when the *rest* are still waiting. It wiped them off
+        // the screen while they were on their way, which reads as messages
+        // two and three having been dropped.
+        act(onFailure = { queued = queued - text }) {
+            sendMessage(settings, summary.id, text, attachments)
+        }
     }
 
     // The system photo picker; the image uploads as soon as it's chosen,
@@ -547,8 +554,7 @@ fun SessionScreen(
                 items(items.asReversed()) { item ->
                     when (item) {
                         is TranscriptItem.UserMsg -> UserBubble(item.text)
-                        is TranscriptItem.AssistantMsg ->
-                            Text(item.text, style = MaterialTheme.typography.bodyLarge)
+                        is TranscriptItem.AssistantMsg -> MarkdownText(item.text)
                         is TranscriptItem.ToolRun ->
                             ToolCard(
                                 tool = item,