feat(plot)!: harden pipeline, XY series, dash/markers, touch, packaging

Breaking: Series::gather emits x relative to x0() and takes a GatherMode;
consumers reconstruct absolute x in f64 before mapping (series.hpp documents
the contract).

Bugs, each pinned by a fail-before regression test:
- render: f32 staging quantised epoch-time x into 128 px columns; every
  data-space draw now stages to_space(x) - to_space(origin) with the origin
  folded into the offset uniform in f64 (epoch/zero-origin twins rasterise
  identically)
- ticks: major test was ULP-fragile and blanked epoch axes; majors are an
  integer-index test and are never truncated by the minor cap
- gather: LOD envelope emitted buckets straddling [begin,end); ceil/floor
  bucket edges + raw lead/trail spans
- live follow: log x axes held a linear span and zoomed every frame; span and
  offset now live in axis space (plot + both figure link-group paths)
- input: a zero-notch wheel disarmed auto_scale on every axis; dy==0 pans x,
  factor == 1 / inf refused in wheel and drag zoom
- render: the single text flush painted legend names over the crosshair
  readout panel; two batches, under flushed before the panel
- data: NaN dropped from min/max unless it seeded the fold; non-finite
  samples are now excluded from every aggregate and from cached bounds

Robustness: viewport normalisation (no clamp UB), non-finite range refusal,
pyramid level cap at 57 (no shift/div UB through public gather), rounded ring
capacity documented + pre-sized, GL blend func and UNPACK_ALIGNMENT
save/restore, Renderer::release_gl() teardown, u64 buffer epochs, annotation
captions clamped, button-aware GLFW row capture, cached figure row rects (no
per-event layout), ruler-pair measurement refused, span-nonfinite guards in
axis_ends.

Features: XY series (sorted x, binary-search neighbours/snap, LOD over sample
index); StreamSeries::freeze(); ArraySeries::push(); per-trace dash and
markers (scatter at width 0) with auto or literal stride; GatherMode
Envelope/Nearest/Mean via bucket_sum/sumsq; Style::line_aa_px; per-glyph text
colour (readout values in trace colour); wheel-dx x pan; arrow-key pan;
Escape cancels a drag and restores captured ranges; modifier-masked box zoom
(Shift both, Ctrl x, Alt y); double-click reset via PointerEvent::time_s;
ImGui key repeat unified; pinch gestures on Qt and GTK; pixelDelta wheel path
and DevicePixelRatioChange handling; GNUInstallDirs, SOVERSION,
SameMinorVersion, generated plot/version.hpp, relocatable plot.pc, licence
install, FILES_MATCHING, GitHub Actions CI (debug/coverage/asan).

Suite 283 -> 350 cases, 0 failed; coverage 93.9% (3730/3971) over 24 files,
floor 80/90 held; ASAN preset suite green; all four demos run headless (the
GTK scripted-resize check needs a window manager and fails identically on the
parent commit); readme_main.cpp committed and compiles with the README
command; pkg-config and find_package consumption verified from a relocated
install prefix.

tests/test_minmax_pyramid.cpp

@@ -290,3 +290,55 @@ PLOT_TEST(pyramid_append_cost_is_amortised_constant) {
   const u64 slid = plot::data::detail::merge_count().load(std::memory_order_relaxed);
   PLOT_CHECK(slid <= kAppends / 16);
 }
+
+// --- B7: non-finite samples are excluded from every aggregate ----------------
+
+PLOT_TEST(pyramid_excludes_non_finite_samples_from_aggregates) {
+  // NaN at the first, middle and last positions of the window, and a whole
+  // all-NaN bucket in the middle: the aggregates never see them.
+  MinMaxPyramid p;
+  p.append(std::nanf(""));                    // first
+  for (int i = 0; i < 63; ++i) p.append(1.0f);
+  for (int i = 0; i < kBucket; ++i) p.append(std::nanf(""));   // bucket 1: all NaN
+  for (int i = 0; i < 63; ++i) p.append(2.0f);
+  p.append(std::nanf(""));                    // last
+  PLOT_CHECK(p.size() == 64 + kBucket + 64);
+  // Bucket 0: 63 ones; bucket 1: empty; bucket 2: 63 twos (the final NaN is
+  // the pending bucket's only sample, never a whole bucket).
+  PLOT_CHECK(p.bucket_count(0, 0) == 63);
+  PLOT_CHECK(p.bucket_count(0, 1) == 0);
+  PLOT_CHECK(p.bucket_count(0, 2) == 63);
+  const Range r0 = p.reduce_buckets(0, kBucket);
+  PLOT_CHECK_NEAR(r0.min, 1.0, 1e-6);
+  PLOT_CHECK_NEAR(r0.max, 1.0, 1e-6);
+  PLOT_CHECK(p.reduce_buckets(kBucket, 2 * kBucket).span() == 0.0);   // the NaN bucket
+  PLOT_CHECK(p.sum_buckets(kBucket, 2 * kBucket) == 0.0);
+  PLOT_CHECK(p.sumsq_buckets(kBucket, 2 * kBucket) == 0.0);
+  // The merge above an empty child keeps the other child's extremes: level 1
+  // bucket 0 covers buckets 0 and 1, and must report the ones, not a 0.
+  PLOT_CHECK(p.level_size(1) >= 1);
+  const MinMax top = p.bucket(1, p.level_base(1));
+  PLOT_CHECK_NEAR(top.min, 1.0, 1e-6);
+  PLOT_CHECK_NEAR(top.max, 1.0, 1e-6);
+  PLOT_CHECK(p.bucket_count(1, p.level_base(1)) == 63);
+  // A range spanning the finite buckets on both sides of the empty one.
+  const Range all = p.reduce_buckets(0, 3 * kBucket);
+  PLOT_CHECK_NEAR(all.min, 1.0, 1e-6);
+  PLOT_CHECK_NEAR(all.max, 2.0, 1e-6);
+  PLOT_CHECK_NEAR(p.sum_buckets(0, 3 * kBucket), 63.0 + 126.0, 1e-6);
+  // bucket_sum / bucket_count is the mean the Mean gather mode folds.
+  PLOT_CHECK_NEAR(p.bucket_sum(0, 0) / f64(p.bucket_count(0, 0)), 1.0, 1e-9);
+}
+
+// --- R3: the deepest level is capped where the span shift still fits ---------
+
+PLOT_TEST(pyramid_level_cap_keeps_the_span_shift_defined) {
+  // Level 57 is the last whose bucket span (kBucket << 57 == 2^63) fits a u64;
+  // past it the shift would be undefined, so the constant pins the cap and
+  // reserve() never materialises more levels than it.
+  PLOT_CHECK((u64{kBucket} << plot::data::kMaxPyramidLevel) == (u64{1} << 63));
+  MinMaxPyramid p;
+  p.reserve(~u64{0});   // a window no sample count can reach: still just the cap
+  p.append(1.0f);
+  PLOT_CHECK(p.level_count() >= 1);
+}