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_measure.cpp

@@ -3,6 +3,7 @@
 
 #include "harness.hpp"
 #include <plot/plot/measure.hpp>
+#include <plot/plot/plot.hpp>
 #include <plot/data/array_series.hpp>
 #include <plot/data/detail/cover_count.hpp>
 #include <algorithm>
@@ -65,3 +66,41 @@ PLOT_TEST(empty_and_single_sample_intervals_are_valid_false) {
   PLOT_CHECK(!plot::Measure::evaluate(s, 0, 0).valid);
   PLOT_CHECK(!plot::Measure::evaluate(s, 1, 1).valid);
 }
+
+PLOT_TEST(a_measure_over_a_ruler_reports_invalid) {
+  // R8: a measurement is read from two *x* coordinates, and a horizontal ruler has
+  // no x -- it is the dead field of its orientation. Evaluating the pair anyway
+  // silently measured from x=0; now the id `add_measure` returns is real but
+  // reports an invalid measurement, and names no band to shade either.
+  plot::Plot p;
+  p.set_viewport({0.0f, 0.0f, 800.0f, 400.0f});
+  p.add_x_axis({"t", {0.0, 100.0}, false, plot::AxisPlace::Bottom, false});
+  p.add_y_axis({"v", {-1.0, 1.0}, false, plot::AxisPlace::Left, false});
+  std::vector<f32> ys(100);
+  for (u64 i = 0; i < 100u; ++i) ys[static_cast<std::size_t>(i)] = f32(i) * 0.01f;
+  plot::data::ArraySeries series(std::move(ys), 0.0, 1.0);
+  p.add_trace({&series, plot::Color::hex(0x40C0FF), 1.5f, 0u, 0u});
+
+  const u32 ra = p.add_h_ruler(0.5, plot::Color::hex(0xFFE080));
+  const u32 rb = p.add_h_ruler(-0.5, plot::Color::hex(0xFFE080));
+  const u32 rulers = p.add_measure(ra, rb);
+  PLOT_CHECK(!p.measurement(rulers).valid);
+  PLOT_CHECK(!p.measure_span(rulers).valid);  // and no band between dead x's to shade
+
+  // A ruler paired with a real marker is refused for the same reason: one half of
+  // the pair has no x to measure from.
+  const u32 ca = p.add_cursor(10.0, plot::Color::hex(0xFFFFFF));
+  const u32 mixed = p.add_measure(ca, ra);
+  PLOT_CHECK(!p.measurement(mixed).valid);
+  PLOT_CHECK(!p.measure_span(mixed).valid);
+
+  // Sanity: a marker pair over the same series still measures. The extremes are
+  // the stored f32 samples' values, so the expectation is derived from the same
+  // arithmetic the store used, not from the decimal literals.
+  const u32 cb = p.add_cursor(20.0, plot::Color::hex(0xFFFFFF));
+  const u32 markers = p.add_measure(ca, cb);
+  const plot::Measurement& m = p.measurement(markers);
+  PLOT_CHECK(m.valid);
+  PLOT_CHECK_NEAR(m.ymin, static_cast<f64>(f32(10) * 0.01f), 1e-12);
+  PLOT_CHECK_NEAR(m.ymax, static_cast<f64>(f32(20) * 0.01f), 1e-12);
+}