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.

CMakeLists.txt

@@ -62,8 +62,15 @@ if(PLOT_BUILD_TESTS)
   # merges so a test can pin the query's O(log n) cost and the append path's
   # amortised O(1) cost, neither of which any answer reveals. Off in every
   # non-test build (see include/plot/data/detail/{cover,merge}_count.hpp).
+  #
+  # PLOT_RING_STATS is the same for the persistent-mapped instance ring: the
+  # properties a frame must hold there -- no slot written twice within a frame,
+  # and one fence wait at most, at the start of the frame -- are invisible in the
+  # pixels, so a test reads counters instead (see
+  # include/plot/render/detail/ring_stats.hpp).
   target_compile_definitions(plot_core PRIVATE PLOT_PYRAMID_COUNT_COVERS
-                                             PLOT_PYRAMID_COUNT_MERGES)
+                                             PLOT_PYRAMID_COUNT_MERGES
+                                             PLOT_RING_STATS)
 
   enable_testing()
   add_subdirectory(tests)