[parashardhapola]

Summary

The mixed-model fits and Kenward and Roger's adjustment run their compiled routines on a
pool of Python threads. When Python's garbage collector starts on one of those threads,
it runs the finalizers of whatever it frees there, and some objects may only be finalized
on the thread that made them. The test suite showed it: on Python 3.14, Tk objects left
by matplotlib's interactive backend were finalized during a mixed-model fit and raised
"main thread is not in main loop". Once, a cold compile on a worker thread crashed the
interpreter inside the collector. Both routines now compile on the calling thread, and
the collector waits until the workers finish.

Changes

• cytepool._jit.by_runs(run, n_items) (private): runs a routine that releases the GIL
  over runs of consecutive items, the first run on the calling thread (which compiles
  the routine, or loads it from the cache) and the others on a pool of Python threads,
  with the garbage collector paused until they finish and restored even when a run
  raises.
• fit_mixed_model (through its private _fit) and Kenward and Roger's adjustment in
  cytepool.stats._fixed_effect_inference use it in place of their own thread pools.
  Each feature is computed by the same operations as before, so every result is
  unchanged to the bit.
• tests/conftest.py: the tests draw figures with matplotlib's Agg backend, as on CI,
  instead of the interactive backend matplotlib chooses where a display is available.

Design notes

• Why pause the collector rather than only compile first: compiling on the calling
  thread removes the compile from the workers, but a collection can still start on a
  worker at any allocation, such as the arguments of each call. Pausing it for the
  length of the pool keeps every finalizer on the calling thread. The workers allocate
  almost nothing that needs collecting, so memory does not grow.
• The first run is about a quarter of one thread's share of the work, so the time lost
  to running it before the pool starts is small.
• numba's own parallel loops (prange) run in native threads without Python state, so
  the routines that use them are not affected.

Tests

tests/test_jit.py gains three tests:

• by_runs covers every item once, in eight runs for two threads, the first on the
  calling thread;
• with one thread it runs everything on the calling thread;
• with the collector running at almost every allocation, objects that only the
  collector frees, made on the workers, are all finalized on the calling thread. The
  same pool without the pause finalized 1,337 of the 1,600 on worker threads.

The mixed-model, Kenward-Roger, dream, design-check and variance-partitioning tests pass
unchanged (191 tests). The full suite on top of the pull requests before it: 4,926
passed, 18 skipped, also with bounds checks and with the rounding changed; Python 3.14:
4,947 passed, without the warning of the Tk objects; Python 3.15: 4,841 passed, 107
skipped.