fix(render): one fence per frame for the vertex ring; two qt6 adapter fixes

The persistent-mapped instance ring had three slots and recorded a fence per
upload, so a frame recycled a slot whose fence was recorded a few draws earlier
*in that same frame*: from the fourth of the demos' nine uploads on, each one
waited on the frame's own work. It is free on a driver that retires draws
promptly (the GLFW host, 1.07 ms/frame) and ~4 ms of the Qt widget's 7.11 ms
under llvmpipe, and it grows with the trace and cursor counts this library
exists for.

* The ring grows to cover a frame's upload count, the frame's write cursor is
  the ring index (so a frame writes 0, 1, 2, ... and never a slot twice), one
  fence is recorded after the frame's last draw, and the only wait is at the
  start of the next frame. A wait that times out, or a slot written with no
  fence ever recorded behind it, drops the store to the orphan path -- the
  treatment a refused fence already had -- so nothing is ever written into
  storage the GPU may still be reading.
* New test-only counters (PLOT_RING_STATS, the PLOT_PYRAMID_COUNT_* pattern:
  free functions, no member, so no consumer's layout changes) pin a frame's
  upload and wait counts. The new tests assert the frame's slot offsets are
  distinct, that the ring grew past its floor to cover the frame, and that a
  frame waits at most once per store -- read from the counters and from
  glClientWaitSync itself.
* qt6: print the unresolved entry-point names before the load-failure branch,
  which used to return first and leave the one failure this widget can have
  reporting nothing but a generic message.
* qt6: the cached pointer anchor is now in logical pixels and a move's delta is
  the logical difference scaled by the DPR in effect, so a scale change between
  two move events (the window dragged onto another monitor mid-drag) is no
  longer a cross-scale jump applied as a pan. The anchor moved into a
  toolkit-free unit (adapters/qt6/qt_pointer.hpp) with its own test.

GLFW demo headless: 1.07 -> 0.73 ms/frame. Qt widget under xvfb/llvmpipe:
7.1 -> 3.8 ms at dpr 1.0, 6.7 -> 3.6 ms at 1.25, with both upload paths still
rendering and the demo's scripted pan/box-zoom checks passing at both scales.

include/plot/render/vertex_array.hpp

@@ -30,11 +30,14 @@ class LineVertexArray {
   void upload(const f32* interleaved, u32 segments) noexcept;
 
   void bind() const noexcept { vao_.bind(); }
-  /// Records that the draw just issued read the instance buffer's current slot,
-  /// which is what lets the mapped path reuse it safely. True in the baseline
-  /// mode, so a caller always calls it the same way. False only when the driver
-  /// refused the fence: the buffer has then fallen back to the baseline path, and
-  /// `persistent()` says so from the next call on.
+  /// Waits, once, for the previous frame's draws to retire the ring before any
+  /// slot of this frame is written (see `InstanceStore::begin_frame`). False when
+  /// the store had to drop to the baseline path; the caller reports it.
+  bool begin_frame() noexcept { return buffer_.begin_frame(); }
+  /// Records the frame's single fence, behind every draw that read the ring (see
+  /// `InstanceStore::mark_drawn`); called once per frame, after its last draw.
+  /// False only when the driver refused the fence: the buffer has then fallen
+  /// back to the baseline path, and `persistent()` says so from the next call on.
   bool mark_drawn() noexcept { return buffer_.mark_drawn(); }
   /// True while this array's instance buffer is the mapped ring (see
   /// `UploadMode`); a failure that falls back clears it.
@@ -62,6 +65,9 @@ class TextVertexArray {
   void upload(const f32* interleaved, u32 glyphs) noexcept;
 
   void bind() const noexcept { vao_.bind(); }
+  /// The line pipeline's frame pair, for the text store (see
+  /// `LineVertexArray::begin_frame` / `mark_drawn`).
+  bool begin_frame() noexcept { return buffer_.begin_frame(); }
   bool mark_drawn() noexcept { return buffer_.mark_drawn(); }
   bool persistent() const noexcept { return buffer_.persistent(); }