Draw replies as pieces of one parse, and lists an item at a time

A settled reply used to be cut into block *strings*, each parsed on its own
and each a unit of the lazy list; the live reply split the same way with a
whole-message parse per delta on top. Now a message is parsed once, and a
Piece addresses a top-level block of that tree -- or one item of a
top-level list, which was the one block still unbounded: a list of forty
sources was one item composed whole in the frame it scrolled into. Units,
the live reply's column and peer messages all draw from the same parse,
so warm parses each message once instead of once per block, a delta costs
one background parse instead of two, and a reference definition at the
foot of a message resolves again because nothing is parsed apart from it.

The renderer keeps parsing and providing its environment; MarkdownRoot
wraps that around a piece, and a whole block still goes through its
dispatch with our component table. List items are drawn here, with the
renderer's own paddings so a split list looks like an unsplit one, and
lists inside quotes come to the same code through the table -- the marker
is drawn in one place, which is what a styled bullet would need later.

Found on the way: a heading's words are a child of the heading node, and
the inline builder draws nothing for a node type it does not know, so the
span-link path had been drawing headings empty. LinkedHeading hands it the
content child.

Lint: profileable's shell attribute scoped to API 29 where it exists, and
recordFrames renamed to the composable convention. What remains is the
AGP 9.4.0 notice.

Verified on the emulator against a fixture of every block kind (headings,
nested and ordered lists with a start number, task items, a quote holding
a list, a fence, a rule, a table with a linked cell, a setext heading), a
forty-item list which the render report now shows as per-item units, a
reply streamed live (34 deltas: 34 background reparses, one warm at
settle, no crash), and the older link fixture. ktfmt, build and lint run.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

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

@@ -78,24 +78,18 @@ fun PeerHeadRow(
  * chose.
  */
 @Composable
-fun PeerBlockRow(
-    text: String,
-    replies: ParsedReplies,
-    last: Boolean,
-    onToggle: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
+fun PeerBlockRow(unit: TranscriptUnit.PeerBlock, replies: ParsedReplies, onToggle: () -> Unit) {
     Column(
-        modifier.cardPiece(
+        Modifier.cardPiece(
             top = false,
-            bottom = last,
+            bottom = unit.last,
             fill = CardDefaults.cardColors().containerColor,
             onPress = onToggle,
         )
     ) {
         // The gap the card's own column used to provide between its heading and its prose, and
-        // between one block and the next. Uniform, because both of those were 6dp already.
-        MarkdownText(text, replies, Modifier.padding(top = BLOCK_SPACING))
+        // between one block and the next -- inside the piece, so the card's fill runs through it.
+        MarkdownPiece(unit.text, unit.piece, replies, Modifier.padding(top = unit.spacing))
     }
 }