Thin the app's comments

The same pass the server had, on the Kotlin side: comments restating what
the code says are gone, and the ones recording a measurement, a constraint
or an incident are kept but cut to a few lines each. 6540 comment lines to
5674, and 920 lines off the app.

Two doc comments had drifted onto the item above the one they describe --
`contextAfter`'s onto `sessionWorking` in Events.kt, and `UsageMonitor`'s
equivalent on the server was fixed in the previous commit. Each is back on
its own item, which is the only non-comment line this diff moves.

The comments are reflowed to the column limit at their own indentation:
several were written wide, and ktfmt re-wrapped them into lines holding a
single orphan word. `/tmp` script, not kept -- ktfmt is idempotent over the
result, which is the check.

Left alone deliberately: this codebase's remaining comment density is high
because the comments carry things the code cannot say -- what a null means,
what a number was measured against, which bug a guard exists for. Of the
238 one-line doc comments in the app, five were pure restatement of the
name and were removed; the rest each say something the signature does not.

ktfmtFormat, compileDebugKotlin, lintDebug and testDebugUnitTest pass;
cargo test (127), clippy --all-targets and fmt still clean.

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

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

@@ -44,27 +44,22 @@ import org.intellij.markdown.flavours.gfm.GFMTokenTypes
  *
  * Compose turns every `LinkAnnotation` in a text into a layout node: a clipped, focusable,
  * hoverable, clickable box laid out against the glyphs, with its outline recomputed from the text
- * layout. A paragraph of eight links is therefore nine nodes, and the renderer emits one of those
- * annotations per link. Measured on the emulator against the same paragraphs with each link
- * replaced by its label and address as plain words -- *more* text, the same gestures -- the linked
- * version cost five times the worst measure (26.3ms against 5.2ms) and 1.7x the place time. On a
- * Pixel 9 Pro XL that was the bump at the list of sources in a reply, and nowhere else in it.
+ * layout. A paragraph of eight links is therefore nine nodes, and the renderer emits one annotation
+ * per link. Measured on the emulator against the same paragraphs with each link replaced by its
+ * label and address as plain words -- *more* text, the same gestures -- the linked version cost
+ * five times the worst measure (26.3ms against 5.2ms) and 1.7x the place time.
  *
  * Here a link is the link colour and underline, a string annotation carrying its address, and one
  * tap detector for the whole text that asks the layout which character was under the finger. What
  * that gives up is a link being its own accessibility node with a pressed state; the app's link
  * style never defined a pressed style, so nothing visible changes.
  *
- * Every block the renderer dispatches through its component table comes here, which includes the
- * paragraphs inside lists, quotes and alerts, and so does every table cell through
- * [LinkedTableRow]. Reference-style links are the one kind still drawn the renderer's way; it
- * resolves those against its definitions.
+ * Every block the renderer dispatches through its component table comes here, and so does every
+ * table cell. Reference-style links are the one kind still drawn the renderer's way.
  *
  * An image is a link too, carrying its alt text. The app has no image loader and the renderer's
  * transformer was the no-op one, so an image in a reply drew as nothing at all -- a hole where the
- * model put something, with no sign of what fell out. The link says what was there and where, and
- * opens it. It also means no paragraph needs the renderer's own text composable, which existed to
- * place inline images and charged every paragraph for the possibility.
+ * model put something. The link says what was there and where, and opens it.
  */
 @Composable
 fun LinkedText(model: MarkdownComponentModel, style: TextStyle) {
@@ -74,8 +69,7 @@ fun LinkedText(model: MarkdownComponentModel, style: TextStyle) {
 /**
  * A heading. Its words are a child of the heading node -- `ATX_CONTENT` after the `#`s, or
  * `SETEXT_CONTENT` above the underline -- and the inline builder draws nothing for a node type it
- * does not know, so handed the heading node itself it draws an empty line. Which is what this did
- * for a week.
+ * does not know, so handed the heading node itself it draws an empty line.
  */
 @Composable
 fun LinkedHeading(model: MarkdownComponentModel, style: TextStyle) {
@@ -113,18 +107,18 @@ fun LinkedText(content: String, node: ASTNode, style: TextStyle, modifier: Modif
     BasicText(
         text = text,
         modifier =
-            // A tap here is either a link or the card's; see [LocalMarkdownTap] for why the
-            // second one has to be answered from inside the text rather than left to the card.
+            // A tap here is either a link or the card's; see [LocalMarkdownTap] for why the second
+            // one has to be answered from inside the text rather than left to the card.
             modifier.then(chipFill).pointerInput(text, onPlainTap) {
                 awaitEachGesture {
                     // Unconsumed is not required: something outside may already be tracking this
                     // press, and it is still the press that may land on a link.
                     awaitFirstDown(requireUnconsumed = false)
-                    // A tap and nothing else. Null when the gesture became something somebody
-                    // else's -- a scroll, or a press held past the long-press timeout, which is
-                    // how a selection starts. The timeout is the load-bearing half: without it a
-                    // press held for a second and released was still an up with nothing consumed,
-                    // so holding a peer message to select from it shut the card instead.
+                    // A tap and nothing else. Null when the gesture became somebody else's -- a
+                    // scroll, or a press held past the long-press timeout, which is how a selection
+                    // starts. The timeout is the load-bearing half: without it a press held for a
+                    // second and released was still an up with nothing consumed, so holding a peer
+                    // message to select from it shut the card instead.
                     val up =
                         withTimeoutOrNull(viewConfiguration.longPressTimeoutMillis) {
                             waitForUpOrCancellation()
@@ -156,27 +150,24 @@ fun LinkedText(content: String, node: ASTNode, style: TextStyle, modifier: Modif
  * usually -- or null where a plain tap means nothing.
  *
  * A composition local because there is nowhere else to put it. The paragraphs of a message are
- * composed by the renderer's own dispatch out of its component table, so nothing between a card and
- * the text inside it is ours to pass a parameter through; the renderer already hands its colours,
- * its typography and its components down the same way.
+ * composed by the renderer's own dispatch, so nothing between a card and the text inside it is ours
+ * to pass a parameter through.
  *
  * It exists because a pointer-input node over the glyphs takes the tap and the card's own click
- * handler never sees it. Measured on the emulator against an opened peer message: with a handler on
- * the text -- consuming or not -- a tap on its words did nothing at all, and with the handler
- * removed entirely the same tap shut the card. So a card whose body is markdown cannot be shut by
- * pressing its words unless the words do the shutting, and "nothing happens when I press it" is
- * indistinguishable from a card that has stopped working.
+ * handler never sees it. Measured against an opened peer message: with a handler on the text --
+ * consuming or not -- a tap on its words did nothing at all, and with the handler removed the same
+ * tap shut the card. So a card whose body is markdown cannot be shut by pressing its words unless
+ * the words do the shutting.
  *
- * Provided as a value that outlives a recomposition (see [rememberMarkdownTap]), since a fresh
- * lambda per composition would invalidate every paragraph reading it.
+ * Provided as a value that outlives a recomposition, since a fresh lambda per composition would
+ * invalidate every paragraph reading it.
  */
 val LocalMarkdownTap = compositionLocalOf<(() -> Unit)?> { null }
 
 /**
- * [onTap] as a stable value to provide for [LocalMarkdownTap].
- *
- * The identity stays put while the behaviour follows the latest [onTap], which is what keeps
- * providing it from invalidating the text under it on every recomposition of the card.
+ * [onTap] as a stable value to provide for [LocalMarkdownTap]. The identity stays put while the
+ * behaviour follows the latest [onTap], which is what keeps providing it from invalidating the text
+ * under it on every recomposition of the card.
  */
 @Composable
 fun rememberMarkdownTap(onTap: () -> Unit): () -> Unit {
@@ -212,9 +203,8 @@ private const val LINK_URL = "url"
  * The chip's fill is drawn by [LinkedText] from the layout instead, behind the text. A span's
  * background is part of the text's own drawing, and the text node draws the selection first and the
  * glyphs over it, so a chip painted as a span background covered the selection: selecting a
- * sentence highlighted every word of it except the ones in backticks. Anything drawn by a modifier
- * on the text is under both, which is where a fenced block's box already is and why one of those
- * always looked right. The [CODE_CHIP] annotation is what says where the fill goes.
+ * sentence highlighted every word except the ones in backticks. Anything drawn by a modifier on the
+ * text is under both, which is where a fenced block's box already is.
  */
 private fun appendCodeChip(
     builder: AnnotatedString.Builder,
@@ -242,13 +232,11 @@ private const val CODE_CHIP = "code"
  * Not `getPathForRange`, which is the geometry of a *selection* and runs to the right edge of every
  * line but the last, so a chip whose code wrapped left a full-width empty box behind on the line
  * above. Each line is taken as far as `visibleEnd`, which is where that line's own trailing space
- * stops being drawn: the same rule the selection rectangle obeys, so the two agree rather than the
- * chip sticking a space out past the end of a selected line. It is also what leaves nothing behind
- * when the only thing to reach a line is the space a chip is padded with.
+ * stops being drawn -- the same rule the selection rectangle obeys, so the two agree.
  *
  * A run's extent is taken from the boxes of its first and last characters, which is exact while a
  * line reads in one direction; mixed directions inside a code span would draw one box across the
- * whole run rather than one per direction, and code spans are code.
+ * whole run, and code spans are code.
  */
 private fun TextLayoutResult.chipRects(start: Int, end: Int): List<Rect> {
     val rects = mutableListOf<Rect>()