Improve: Private claim cursors for for_n_dynamic

A single shared counter serialized every dynamic dispatch: one core at a time
may own its cache line, so no dispatch retired tasks faster than that line
circulated. At a grain of 8 iterations per task, 18 threads spent 288 ms where
a static split spent 8 ms.

Give each thread its own cursor over a contiguous slice. A thread drains its
own slice with an uncontended `fetch_add`, then walks the others in a coprime
order and drains theirs. Tasks are still claimed one at a time, so the makespan
guarantee of greedy list scheduling survives; only the cost of a claim changes.
An uncontended read-modify-write measures 0.13 ns here against 6.63 ns for a
contended one, and two sharers cost nearly what eighteen do - the price is the
line transfer, not the crowd. The same dispatch now takes 9.0 ms.

No compare-exchange is used: under contention it measured 26.4 ns per success
with 1.3 retries, four times the cost of `fetch_add`. This mirrors what
`invoke_distributed_for_n_dynamic` already did across compute domains, one
level down.

The cursors allocate nothing. `basic_pool` folds each into the padded per-thread
cell that already holds its `std::thread`, and the NUMA pool folds each into the
`numa_pthread_t` it already allocates on the right node. A single-thread pool
allocates nothing at all and runs the loop directly.

Also fixes two defects found on the way:

- `coprime_permutation_range` was not a permutation for small index types.
  `offset_ + stride_` was truncated before the wrap, so on `std::uint8_t` over a
  length of 253 it revisited 155 values and skipped 155. A stealing thread would
  drain a victim twice, overrun its cursor past the index type, and re-run tasks.
  The test only counted values and checked bounds, so it never noticed; it now
  asserts each value appears exactly once.
- `basic_pool::try_spawn` rolled back by deallocating `threads` objects where it
  had allocated `worker_threads`.