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>

server/src/main.rs

@@ -188,19 +188,18 @@ async fn main() -> Result<()> {
     .await
     .context("failed to load TLS cert/key")?;
 
-    let monitor = Arc::new(usage::UsageMonitor::new(vec![Box::new(
-        usage::ClaudeUsage {
-            credentials_path: std::env::home_dir()
-                .unwrap_or_else(|| PathBuf::from("/"))
-                .join(".claude/.credentials.json"),
-        },
-    )]));
+    // No providers listed here any more: which machines can be asked, and
+    // about what, comes from the setups at the moment the screen is opened
+    // -- so a machine added from the phone reports its limits without a
+    // restart, and the backend's own account stops standing in for every
+    // machine's.
+    let monitor = Arc::new(usage::UsageMonitor::new());
 
     // The bearer-token middleware wraps the entire router -- routes and
     // fallback alike -- here and only here, so a new route can't forget
     // auth. Zero unauthenticated endpoints.
     let app = routes::router(Arc::clone(&manager))
-        .merge(routes::usage_router(monitor))
+        .merge(routes::usage_router(monitor, Arc::clone(&manager)))
         .merge(routes::models_router(Arc::clone(&models)))
         .layer(axum::middleware::from_fn_with_state(
             Arc::clone(&manager),