fix(plot,render,gl): live streaming measurements, handed-back GL state

Final whole-branch review fixes.

1 (Important). Plot::measurement() cached on (series pointer, sample count)
only, so a saturated StreamSeries -- whose size() stays pinned while x0()
advances every acquire() -- froze its readout on the first saturated frame
until a cursor moved. The cache key now carries the series' x0() (new
MeasureSlot::last_x0), so a sliding window recomputes and a static series
still does not: asserted with a new macro-gated counter hook
(plot/detail/measure_count.hpp, PLOT_COUNT_MEASURE_RECOMPUTES, wired like the
pyramid and ring counters, absent from the release library). New case
saturated_stream_measurement_tracks_the_sliding_window: saturated ring,
stationary cursors, ramp in absolute x -- zero recomputes for repeated reads
with nothing moving, one per acquire while it slides.

2-3, 9. Spec: 4.3 described a GL_LINE_STRIP path that does not exist (there is
one rasteriser -- instanced anti-aliased quads -- and dense_threshold_spp
selects the gather level, not a primitive); 8 named a PLOT_GL_CHECK() macro
that exists nowhere, and stated no exception policy. The table, the field's
comment and 8 now describe the real gather-level threshold, the real
glGetError() drain plus the stores' drop-to-orphan fallbacks, and the real
policy: library failures return Status/bool, allocating entry points propagate
std::bad_alloc.

4. The frame handed back neither GL_UNPACK_ALIGNMENT (init() sets 1 for the
atlas) nor the clear colour (queried once with a new glGetFloatv entry).
end_frame() restores both and renderer.hpp lists them in the residue
contract.

5. draw() kept a host TextBackend for layout while drawing with its own font.
The renderer now installs its font unconditionally -- strips and labels measure
and draw with one backend -- with a debug-build diagnostic if a different one
was set, and Plot::set_text_backend() is documented as the no-renderer path.
New case renderer_measures_the_labels_it_draws asserts layout, measuring and
the drawn label's ink agree.

6-10. draw()'s style overwrite stated at the call site; the load-sensitive
wall-clock bound in test_measure.cpp replaced by a counter assertion (same
interval, same fold count over a 512x length ratio); dump_frame_ppm drops
noexcept and says why it may allocate; error.txt ignored (not this project's,
not generated here) rather than deleted.

Verified: debug and release build clean (-Wall -Wextra -Wpedantic -Wconversion
-Wshadow), 4/4 ctest entries pass, 130 cases pass (was 127), umbrella and
header self-containment checks pass, and no counter symbol in the release
archive.

tests/test_plot.cpp

@@ -1,5 +1,6 @@
 #include "harness.hpp"
 #include <plot/plot/plot.hpp>
+#include <plot/plot/detail/measure_count.hpp>
 #include <plot/data/array_series.hpp>
 #include <plot/data/stream_series.hpp>
 #include <plot/render/bitmap_font.hpp>
@@ -310,6 +311,71 @@ PLOT_TEST(measurement_recomputes_when_the_series_grows) {
   PLOT_CHECK_NEAR(p.measurement(m).dx, 18.0, 1e-9);
 }
 
+/// A saturated ring pins size() at capacity while x0() advances every acquire(),
+/// so a cache keyed on (pointer, sample count) alone would freeze this measurement
+/// on the first saturated frame -- the one case the demos never reach, because they
+/// move their cursors (and therefore `dirty`) every frame.
+///
+/// The signal is a ramp in absolute x, so the value a cursor names once the window
+/// has slid past it is the current window's oldest sample: a live cache tracks
+/// x0(), a frozen one keeps reporting the first frame's numbers. The counter is the
+/// other half of the contract -- a frame in which nothing moved is still a cache
+/// hit, or the fix would have traded a stale readout for a per-frame recompute.
+PLOT_TEST(saturated_stream_measurement_tracks_the_sliding_window) {
+  constexpr u64 kCapacity = 64;
+  plot::data::StreamSeries s(kCapacity, 0.0, 1.0);
+  for (u64 i = 0; i < kCapacity; ++i) s.push(f32(i));   // y == absolute x
+  s.acquire();
+  PLOT_CHECK(s.size() == kCapacity);                    // published window is full
+
+  plot::Plot p;
+  p.set_viewport({0.0f, 0.0f, 800.0f, 400.0f});
+  const u32 ax = p.add_x_axis({"t", {0.0, 100.0}, false, plot::AxisPlace::Bottom, false});
+  const u32 ay = p.add_y_axis({"v", {0.0, 100.0}, false, plot::AxisPlace::Left, false});
+  p.add_trace({&s, plot::Color::hex(0xFFFFFF), 1.0f, ax, ay});
+  const u32 a = p.add_cursor(10.0, plot::Color::hex(0xFFB020));
+  const u32 b = p.add_cursor(60.0, plot::Color::hex(0xFFB020));
+  const u32 m = p.add_measure(a, b);
+
+  // First window, both cursors inside it: y over absolute x 10..60.
+  PLOT_CHECK(p.measurement(m).valid);
+  PLOT_CHECK_NEAR(p.measurement(m).ymin, 10.0, 1e-9);
+  PLOT_CHECK_NEAR(p.measurement(m).ymax, 60.0, 1e-9);
+  PLOT_CHECK_NEAR(p.measurement(m).mean, 35.0, 1e-9);
+  PLOT_CHECK_NEAR(p.measurement(m).dx, 50.0, 1e-9);
+
+  auto counter = [] {
+    return plot::detail::measure_recomputes().load(std::memory_order_relaxed);
+  };
+  plot::detail::measure_recomputes().store(0, std::memory_order_relaxed);
+  // Neither cursor moves and neither does the window: eight reads, no recompute.
+  for (int i = 0; i < 8; ++i) (void)p.measurement(m);
+  PLOT_CHECK(counter() == 0u);
+
+  // Slide the window past cursor `a` -- 40 more samples and an acquire, with the
+  // sample count unchanged (still capacity) and neither cursor touched.
+  for (u64 i = kCapacity; i < kCapacity + 40; ++i) s.push(f32(i));
+  s.acquire();
+  PLOT_CHECK(s.size() == kCapacity);                    // size() cannot be the key
+  PLOT_CHECK_NEAR(s.x0(), 40.0, 1e-9);                  // x0() moved under it
+
+  const plot::Measurement& slid = p.measurement(m);     // one acquire, one recompute
+  PLOT_CHECK(counter() == 1u);
+  PLOT_CHECK(slid.valid);
+  PLOT_CHECK_NEAR(slid.ymin, 40.0, 1e-9);               // `a` clamped onto the new x0()
+  PLOT_CHECK_NEAR(slid.ymax, 60.0, 1e-9);
+  PLOT_CHECK_NEAR(slid.mean, 50.0, 1e-9);
+  PLOT_CHECK_NEAR(slid.dx, 20.0, 1e-9);
+
+  // And it keeps tracking, one recompute per acquire with the cursors still.
+  for (u64 i = 0; i < 5; ++i) {
+    s.push(f32(kCapacity + 40 + static_cast<f64>(i)));
+    s.acquire();
+    PLOT_CHECK_NEAR(p.measurement(m).ymin, 41.0 + static_cast<f64>(i), 1e-9);
+    PLOT_CHECK(counter() == 2u + i);
+  }
+}
+
 PLOT_TEST(inverted_and_out_of_range_measurements_are_invalid) {
   plot::data::ArraySeries s(ramp(10), 0.0, 1.0);
   plot::Plot p;