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

@@ -536,21 +536,21 @@ PLOT_TEST(text_batch_stages_one_quad_per_glyph) {
   b.begin();
   const plot::Vec2 end = b.add_text("12.5 ms", {0.0f, 0.0f}, 1.0f, f);
   PLOT_CHECK(b.glyph_count() == 7);
-  PLOT_CHECK(b.data().size() == 42);                 // x,y,u,v,ax,ay per glyph
+  PLOT_CHECK(b.data().size() == 70);                 // x,y,u,v,ax,ay,r,g,b,a per glyph
   PLOT_CHECK_NEAR(end.x, f.measure("12.5 ms"), 1e-6);
   PLOT_CHECK_NEAR(end.y, 0.0, 1e-6);
   PLOT_CHECK_NEAR(b.data()[0], 0.0, 1e-6);           // first cell at the pen
   PLOT_CHECK_NEAR(b.data()[1], 0.0, 1e-6);
-  PLOT_CHECK_NEAR(b.data()[6], f.glyph('1')->advance, 1e-6);  // pen advanced per glyph
+  PLOT_CHECK_NEAR(b.data()[10], f.glyph('1')->advance, 1e-6);  // pen advanced per glyph
   // The staged cell's UV is the glyph's own atlas rect (see `Glyph`), and the
   // basis of an unrotated run is the screen's +x. '.' is the string's third
-  // glyph, so its instance is the third: floats 12..17.
+  // glyph, so its instance is the third: floats 20..29.
   const plot::render::Glyph* dot = f.glyph(static_cast<plot::u32>('.'));
   PLOT_CHECK(dot != nullptr);
-  PLOT_CHECK_NEAR(b.data()[14], dot->u0, 1e-6);
-  PLOT_CHECK_NEAR(b.data()[15], dot->v0, 1e-6);
-  PLOT_CHECK_NEAR(b.data()[16], 1.0, 1e-6);          // ax
-  PLOT_CHECK_NEAR(b.data()[17], 0.0, 1e-6);          // ay
+  PLOT_CHECK_NEAR(b.data()[22], dot->u0, 1e-6);
+  PLOT_CHECK_NEAR(b.data()[23], dot->v0, 1e-6);
+  PLOT_CHECK_NEAR(b.data()[24], 1.0, 1e-6);          // ax
+  PLOT_CHECK_NEAR(b.data()[25], 0.0, 1e-6);          // ay
   // Every glyph a batch stages is read through one cell, and the batch publishes
   // it for the draw (`u_glyph_uv`).
   PLOT_CHECK_NEAR(b.glyph_cell_uv().x, dot->u1 - dot->u0, 1e-6);
@@ -571,7 +571,7 @@ PLOT_TEST(text_batch_stages_one_quad_per_glyph) {
   PLOT_CHECK(b.glyph_count() == 2);
   PLOT_CHECK_NEAR(scaled.x, 10.0f + 2.0f * f.measure("AW"), 1e-6);
   PLOT_CHECK_NEAR(scaled.y, 4.0, 1e-6);
-  PLOT_CHECK_NEAR(b.data()[6], 10.0f + 2.0f * f.glyph('A')->advance, 1e-6);  // second cell's pen
+  PLOT_CHECK_NEAR(b.data()[10], 10.0f + 2.0f * f.glyph('A')->advance, 1e-6);  // second cell's pen
 }
 
 // The pen follows the basis, not the screen axes. A run staged with `axis` has to
@@ -599,13 +599,13 @@ PLOT_TEST(text_batch_advances_along_its_basis) {
   PLOT_CHECK_NEAR(up.x, pen.x, 1e-6);
   PLOT_CHECK_NEAR(up.y, pen.y - width, 1e-4);
   for (plot::u32 i = 0; i < b.glyph_count(); ++i) {
-    PLOT_CHECK_NEAR(b.data()[6u * i + 4u], 0.0, 1e-6);
-    PLOT_CHECK_NEAR(b.data()[6u * i + 5u], -1.0, 1e-6);
+    PLOT_CHECK_NEAR(b.data()[10u * i + 4u], 0.0, 1e-6);
+    PLOT_CHECK_NEAR(b.data()[10u * i + 5u], -1.0, 1e-6);
   }
   // The second cell is one advance further up than the pen, which is the same rule
   // the unrotated case follows in x.
-  PLOT_CHECK_NEAR(b.data()[6], pen.x, 1e-6);
-  PLOT_CHECK_NEAR(b.data()[7], pen.y - f.glyph('1')->advance, 1e-6);
+  PLOT_CHECK_NEAR(b.data()[10], pen.x, 1e-6);
+  PLOT_CHECK_NEAR(b.data()[11], pen.y - f.glyph('1')->advance, 1e-6);
 
   // A diagonal direction is normalised, so a caller can hand over any direction
   // and the basis the shader receives is still unit.
@@ -616,6 +616,33 @@ PLOT_TEST(text_batch_advances_along_its_basis) {
   PLOT_CHECK_NEAR(b.data()[5], 0.8, 1e-5);
 }
 
+// The tint is per instance (`a_colour`, the last four floats of every glyph),
+// not a uniform: one batch can carry runs of several colours, which is what the
+// crosshair readout needs (values in each row's trace colour, labels in the axis
+// text colour, one draw call). The staged colour is exactly what the caller
+// passed, straight alpha, on every glyph of the run and nothing else.
+PLOT_TEST(text_batch_stages_its_colour_per_instance) {
+  plot::render::EmbeddedMonoFont f;
+  plot::render::TextBatch b;
+  const plot::Color tint{0.25f, 0.5f, 0.75f, 0.9f};
+  b.begin();
+  b.add_text("AB", {0.0f, 0.0f}, 1.0f, f, {1.0f, 0.0f}, tint);
+  PLOT_CHECK(b.glyph_count() == 2);
+  for (plot::u32 i = 0; i < 2; ++i) {
+    PLOT_CHECK_NEAR(b.data()[10u * i + 6u], tint.r, 1e-6);
+    PLOT_CHECK_NEAR(b.data()[10u * i + 7u], tint.g, 1e-6);
+    PLOT_CHECK_NEAR(b.data()[10u * i + 8u], tint.b, 1e-6);
+    PLOT_CHECK_NEAR(b.data()[10u * i + 9u], tint.a, 1e-6);
+  }
+  // A second run in another colour keeps its own tint per instance -- the old
+  // uniform-tint pipeline could not express this in one batch.
+  b.add_text("CD", {20.0f, 0.0f}, 1.0f, f, {1.0f, 0.0f},
+             plot::Color{1.0f, 1.0f, 1.0f, 1.0f});
+  PLOT_CHECK(b.glyph_count() == 4);
+  PLOT_CHECK_NEAR(b.data()[26u], 1.0, 1e-6);  // 'C' is white where 'A' was not
+  PLOT_CHECK_NEAR(b.data()[6u], 0.25, 1e-6);       // ... and 'A' still carries its own
+}
+
 /// A backend whose atlas is *not* a fixed-cell grid: it declares the cell its
 /// pipeline needs and then publishes one glyph trimmed to its ink, which is what
 /// a naive TrueType packing produces (`stbtt_GetCodepointBitmap` hands back an ink
@@ -844,8 +871,8 @@ PLOT_TEST(add_text_skips_a_codepoint_the_backend_cannot_draw) {
   // glyph of its own, which the second instance's atlas rect says outright.
   PLOT_CHECK_NEAR(batch.data()[0], pen.x, 1e-6);
   PLOT_CHECK_NEAR(batch.data()[2], a->u0, 1e-6);
-  PLOT_CHECK_NEAR(batch.data()[6], pen.x + a->advance, 1e-6);
-  PLOT_CHECK_NEAR(batch.data()[8], b->u0, 1e-6);
+  PLOT_CHECK_NEAR(batch.data()[10], pen.x + a->advance, 1e-6);
+  PLOT_CHECK_NEAR(batch.data()[12], b->u0, 1e-6);
 
   // A run of nothing but undrawable codepoints stages nothing at all and leaves
   // the pen where it was, rather than drawing at the pen.