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.

src/ui_trigger.cpp

@@ -756,11 +756,12 @@ GtkWidget* build_trigger_panel(App& app) {
       "acquisitions are also bounded by the buffer's own size");
   app.trigger_persist_row = row_for(ui, "persistence_row", app.trigger_persist_spin);
 
-  // The phosphor *density*: one screen-sized image every acquisition is accumulated into, drawn
-  // behind the traces and fading by a time constant or by a per-acquisition factor -- the other
-  // display of the same acquisitions, and nothing like the multiple-event one above (N traces
-  // against one image, and no count to choose). It applies in trigger mode only, which the body
-  // already is: the whole block goes insensitive with the trigger off, the panel's own rule.
+  // The phosphor *density*: one screen-sized image per trace, in that trace's own colour, every
+  // acquisition accumulated into it, drawn *in place of* the traces and fading by a time constant
+  // or by a per-acquisition factor -- the other display of the same acquisitions, and nothing like
+  // the multiple-event one above (an image per signal against N retained traces, and no count to
+  // choose). It applies in trigger mode only, which the body already is: the whole block goes
+  // insensitive with the trigger off, the panel's own rule.
   app.trigger_density_switch = gtk_switch_new();
   gtk_widget_set_valign(app.trigger_density_switch, GTK_ALIGN_CENTER);
   gtk_widget_set_halign(app.trigger_density_switch, GTK_ALIGN_END);
@@ -771,9 +772,10 @@ GtkWidget* build_trigger_panel(App& app) {
   }
   gtk_widget_set_tooltip_text(
       app.trigger_density_switch,
-      "accumulate every triggered acquisition into one screen-sized image, drawn behind the "
-      "traces: brightness is how often a trace passed, so an image of a thousand acquisitions "
-      "costs what one costs. Trigger mode only, and cleared whenever the display leaves it");
+      "accumulate every triggered acquisition into a screen-sized image per signal, in that "
+      "signal's own colour, drawn in place of the traces: brightness is how often a trace passed, "
+      "so an image of a thousand acquisitions costs what one costs. Trigger mode only, and cleared "
+      "whenever the display leaves it");
   g_signal_connect(app.trigger_density_switch, "notify::active",
                    G_CALLBACK(on_density_toggled), &app);
   // Not `row_for()`: it expands its child, and an expanded switch is a wide pill that reads as a