fix: persistence is the trace's own phosphor, not a density behind a stroke

The plotter now deposits every acquisition -- the newest included -- into one grid per trace and
draws no solid trace over it, each grid in that trace's colour and with a one-sweep ceiling (its own
commit, **1b8b55d**). This side needed almost no change of its own, because the colour was already
the trace's and the trace's colour is `RowSet::signal_color()` -- the invariants' one route -- but the
figures it reads back are now per trace:

- **The ceiling is left at the library's default of one sweep**, no longer derived from the fade.
  Deriving it from the steady state is the gain offset the user reported between the latest
  acquisition and the persistent image; a signal crossing the same place every acquisition now settles
  at the trace's colour, at full strength, and the newest sweep reads as the trace it is a picture of.
- **`cells`/`grid_bytes` are the sum over the row's traces** -- one grid each, a trace with no series
  holding none -- and both the probe and the exit dump carry `traces=` beside `rows=`. That is what
  makes the per-signal memory figure read: **556 537 cells and 2.2 MB per signal**, at 8904600 bytes
  over the four one-signal rows of the probe's run.

The probes, re-read on this build (the `verification.md` command, `--rate 500000 --batch 1000`):

    [density-probe] off enabled=0 ... rows=0 traces=0 cells=0 ink=0.0 peak=0.0000
    [density-probe] on enabled=1 ... rows=4 traces=4 cells=2226150 ink=226786.0 peak=1.0000
    [density-probe] step-acquisitions ... peak=1.5000
    [density-probe] time-before ... peak=2.1359
    [density-probe] step-time ... ratio=0.367879
    [density-probe] frame cost: tick 0.62 -> 6.96 ms (184/23 frames), draw 2.02 -> 6.16 ms (177/18)
    [udpscope]   density: frames=748 rows=4 traces=4 cells=2226150 grid_bytes=8904600 ink=489400.2 peak=2.2 upload_bytes=2226150

`on` `peak=1.0000`, `step-acquisitions` `peak=1.5000` and `step-time` `ratio=0.367879` are the legs
that were expected, unchanged; the *draw* mean is now **below** the run before the split (2.02 -> 6.16
against 2.09 -> 20.91), because the solid traces are no longer drawn over the image.

Docs updated with it: the trigger manual page (`persistence` is the trace, one image per signal, the
newest included), the README's persistence section, `invariants-trigger-and-pinning.md` (five rules,
the ceiling and the no-stroke rule among them), `verification.md` and `probe-readings.md` (the lines
above), the trigger panel's comment and tooltips, and the plotter submodule.

`cmake --build build --clean-first -j4`: **0 errors, the documented three warnings** (two
`MathNode::source`, one `-Woverlength-strings` at 12352); `make -C build test-ui` **13 ok**;
`make -C build test-help` **green** (15 pages); the self-check **0 `Gtk-WARNING`/`Gtk-CRITICAL`** and
`gtk warnings: 0`, two `buffer allocated:` lines.

README.md

@@ -1269,14 +1269,21 @@ pinned: the axis, the framing and every measurement still describe the event on
 `N = 1` retains nothing at all — no copy, no layer — and lowering the depth frees the retained
 snapshots there and then, because a trigger that has stopped firing never reaches another publish.
 
-**Persistence: one image, every acquisition.** The trigger panel's `Advanced` block carries the
-*other* display of the same acquisitions, and it is not a count at all: `persistence` turns on a
-**phosphor density** — the plotter's screen-sized intensity image (`Plot::set_density()`, one `f32`
-cell per device pixel of the axes rect) into which every triggered acquisition is deposited and
-which is drawn behind the traces. A cell's brightness is how many acquisitions passed through it,
-so the sweep on screen is the brightest, the older ones add on top **with no depth to choose and no
-memory that grows with them** — the image is 2.2 MB over four 573x412 rows in the probe's run, and
-a thousand acquisitions cost the same. `fades by` picks how it decays: `acquisitions` (each
+**Persistence: one image per signal, every acquisition.** The trigger panel's `Advanced` block
+carries the *other* display of the same acquisitions, and it is not a count at all: `persistence`
+turns on a **phosphor density** — the plotter's screen-sized intensity image (`Plot::set_density()`,
+one `f32` cell per device pixel of the axes rect **per trace, in that trace's own signal colour**)
+into which every triggered acquisition is deposited, the newest included, and which is drawn *in
+place of* the traces. The current acquisition is therefore a sweep *inside* the image and fades with
+the rest; no solid polyline is drawn over it, which is what a report of "the persistent image plus
+the last acquisition, and the last one never fades in time mode" turned out to be. A cell's
+brightness is how many acquisitions passed through it — one sweep's ink is the trace's own colour,
+and where several agree it clamps there rather than going white — so the display brightens where the
+signal is steady and dims where it only passed, **with no depth to choose and no memory that grows
+with the acquisitions**: the cost is the screen's times the traces on it (2.2 MB over the probe's
+four one-signal rows; the default four signals in one 800x480 row are 6 MB) and a thousand
+acquisitions cost the same. Each signal is a separate image, so two signals agreeing in a cell read
+as two colours and not one blended grey. `fades by` picks how it decays: `acquisitions` (each
 acquisition keeps the factor of what was before it, 0.5 by default — the phosphor afterglow
 schedule) or `time` (a time constant in stream seconds, so the display fades while you watch
 whatever the trigger rate). It applies in **trigger mode only** — while a captured acquisition is
@@ -1285,7 +1292,8 @@ is an image *of* a stream of acquisitions. Like the invalid-span bands it reserv
 and nothing on it can be picked. The `[density-probe]` run that measured it is in
 `docs/claude/probe-readings.md`; what it costs is in the same place (`[density-probe] frame cost:`:
 tick 0.74 → 9.99 ms and draw 2.09 → 20.91 ms over the same run, at four rows and 2.2 M cells a
-frame, on llvmpipe).
+frame, on llvmpipe — measured before the per-trace split, when the one image was still re-filled
+per row).
 
 **And it says what it costs.** A retained acquisition is a whole window copied out of the ring, so
 the retention is bounded by two things: the depth, and **`--buffer-mb`** — persistence may hold at