Colour the composer by what its buttons do, and let the read-out breathe less

Queue is the paper plane with a clock on it (`md-send_clock`) rather than
the plain plane plus the word: the pair is now told apart by the mark, which
is what an icon is for, and the word survives as the button's accessible
name where a screen reader still needs it.

The three composer buttons take their colour from what pressing one does --
green sends now, blue sends later, red takes the running turn away -- and
Stop becomes a filled button like the other two. Outlined said it was a
qualifier on the primary action; it is a second thing you can do about the
turn, and what separates them is the colour and the mark. The fills are
named in Theme.kt with their content colour stated beside them, because a
semantic colour has to carry its own contrast: these do not change with the
surface, so nothing will rescue a foreground that stops being readable.
Worth knowing when reading that file: the action greens and reds sit next to
a `runningColor` green and a `failedColor` red, which are *states*. Nothing
in one set is pressable and nothing in the other is a state, so a reader
never has to tell them apart.

The usage read-out loses its per-machine cards. A card is a step up the
surface ladder and inside a dialog -- already a raised surface -- the step
barely rendered while costing 16dp on every side. The machine and the
service it answered for are one small quiet line instead of a heading over a
subtitle, since the numbers underneath are what somebody opened this to see.

The gaps between the bars now go *between* them rather than after each,
which is what put a band of empty dialog above Close. The rest of that band
was AlertDialog's own spacing, fixed at sizes meant for a sentence of prose
and a decision, so this is a plain Dialog with the same container colour and
corner and spacing chosen for a dense read-out.

Looked at on the emulator: green send, then blue queue beside red stop
during a `/slow 20` echo turn, and the dialog over the live session. The
account had risen to 78% by then, which showed the five-hour bar and the
header glyph going yellow on real numbers rather than forced ones.

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

@@ -1,5 +1,7 @@
 package com.example.aiapp
 
+import androidx.compose.material3.ButtonColors
+import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.darkColorScheme
 import androidx.compose.runtime.Composable
@@ -206,3 +208,35 @@ val linkColor: Color
 /** Past a limit. The scheme's error colour, for the reason [failedColor] gives. */
 val overLimitColor: Color
     @Composable get() = MaterialTheme.colorScheme.error
+
+/**
+ * The composer's three buttons, coloured by what pressing one does rather than by where it sits.
+ *
+ * Green sends now, blue sends later, red takes the running turn away. The pair of greens and the
+ * pair of reds elsewhere in this file are deliberate near-collisions worth naming: [runningColor]
+ * is green because a session is working, and [failedColor] is red because one fell over -- those
+ * are *states*, and these are *actions*. A reader never has to tell them apart, because nothing
+ * here is a state and nothing there is pressable.
+ */
+val sendColor: Color
+    @Composable get() = Mocha.Green
+
+/** Sending while a turn runs: the message waits rather than starting one. See [sendColor]. */
+val queueColor: Color
+    @Composable get() = Mocha.Blue
+
+/** Interrupting the running turn -- the one button here that takes something away. */
+val stopColor: Color
+    @Composable get() = Mocha.Red
+
+/**
+ * A filled button in one of the action colours above.
+ *
+ * The content colour is stated here beside the fill rather than inherited. A semantic colour has to
+ * carry its own contrast: these fills are fixed whatever the surface under them does, so the theme
+ * will not change to rescue a foreground that stops being readable on one of them. Crust is what
+ * every accent on this palette takes, which is the same reason `onPrimary` is Crust above.
+ */
+@Composable
+fun actionButtonColors(fill: Color): ButtonColors =
+    ButtonDefaults.buttonColors(containerColor = fill, contentColor = Mocha.Crust)