docs: a pause publish costs no packets, and the look is checked with frame path

An A/B of the same fast-mock run with and without a pause reads gaps=0 both
ways, the paused one having published in 86 ms -- so the gaps=73 recorded
yesterday as "a pause costs packet gaps, unexplained" was incidental load on
one run. It never scaled with the publish length and has not reproduced.

Record the publish figures as the range they actually span across runs
(event 69-115 ms, pause 22-86 ms) rather than as single readings, and name
`frame path:` across a pause as the check that the paused trace is drawn like
a live one -- raw=1 lod=555 against raw=0 lod=373, where the defect read
raw=21 lod=118.

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

README.md

@@ -995,10 +995,17 @@ cheaper case than a capture — it freezes the same rings.**
 It is not free, and the trade is one-off against per-frame. Building the pause pyramid took
 that publish from 6.15 ms to 22.31 ms, and unlike the event publish this one runs on the
 **UI** thread and so blocks the *producer* — against ~5 ms a frame of draw for as long as the
-pause lasts, which over a 1.6 s pause at ~60 fps repays thirty times over. One finding there
-is still open: a run that pauses reports `gaps=73` where the same run without a pause reads
-`gaps=0`, and it does **not** scale with the publish length (79 gaps with the pyramid build
-removed, 73 with it), so the stall is not what it is.
+pause lasts, which over a 1.6 s pause at ~60 fps repays thirty times over. The producer
+absorbs it: an A/B of the same fast-mock run with and without a pause read `gaps=0` both
+ways, with the pause publish at 86 ms in the paused one. (One earlier run reported `gaps=73`
+with a pause against 0 without, which is why the stall was worth measuring at all — but it
+has not reproduced, it did not scale with the publish length, and an 86 ms publish costing
+nothing is the stronger reading. Treat that 73 as incidental load on one run.)
+
+The verification that the *look* is restored is the same A/B read through `frame path:`:
+`raw=0 lod=373 columns=373 graded=373` without a pause against `raw=1 lod=555 columns=555
+graded=555` with one — the same path, the same 24711-segment worst frame and a segment mean
+within 5 % — where before the fix the paused run read `raw=21 lod=118`.
 
 The self-check's two `frame cost:` / `frame path:` lines are the guard: they split a frame
 into the tick, the plot's own draw and the whole GTK paint, and report the segment counts
@@ -1765,14 +1772,13 @@ now — they are listed so they are not mistaken for anything else:
   latch after arming with no pre-trigger history. What a second ring would buy is the
   publish: freezing a whole `BufferStore` copies nothing and inherits the pyramid the
   producer already maintains, so both figures in the dump's `publish cost:` line would
-  go to zero. They are worth knowing before pricing that — one event publish measured
-  **115 ms of blocked UI tick** at 1.3 MS/s and one pause publish **22 ms of blocked
+  go to zero. They are worth knowing before pricing that — at 1.3 MS/s an event publish
+  measured **69–115 ms of blocked UI tick** and a pause publish **22–86 ms of blocked
   producer** — but they do not pay for a second budget's worth of memory, a second
   per-sample write on the producer, and a single frozen slot where the app today holds
-  an event, a pause and an export's window at once. One thing to settle first: a run
-  that pauses reports `gaps=73` against `gaps=0` without a pause, and that does not
-  scale with the publish length, so it is not the stall and a second ring would not
-  obviously fix it.
+  an event, a pause and an export's window at once. The *observable* cost is also
+  smaller than the stall: an A/B with and without a pause read `gaps=0` both ways, so
+  what a second ring would buy is a smoother frame at a latch, not recovered packets.
 - **The buffer is allocated at the first CONFIG, not at initialisation.**
   The spec's "N+1 split" needs N, which only a CONFIG gives; `--buffer-mb` is the
   *budget*, and the power-of-two ring rounding means the final