Stop ten test assertions from measuring the runner instead of the code - #10897

#10868 replaced the linearity check in test_pr5624_regressions.py after it
failed on #10825 and again on #10864 at 6.56 against a 6.0 bound, both times on
branches that touch none of that code. The same shape is elsewhere in the suite:
sub-100ms budgets, two separately-taken durations compared against each other,
and concurrency proved by how long four threads took. All of them run under
pytest -n 4 on a shared runner, where descheduling is indistinguishable from the
regression they guard.

Each one is rewritten to assert the thing it is named for.

test_llama_cpp_wait_for_vram_settle.py has five, all of them claims about the
helper's sleeping: did it skip the wait, nap once per poll, clip the last nap to
the deadline. Record the durations it asks for and assert on those. The tightest
was elapsed < 0.05 around a short-circuit, which one GC pause exceeds.

test_account_model_access.py proved eight probes ran together by taking under
0.4s. Its own sibling two functions up already uses a threading.Barrier for the
same claim, so use one here too, sized off _PROBE_FANOUT so lowering the fan-out
fails this rather than satisfying a Barrier(1).

test_mcp_http_sessions.py had three. Two chats running concurrently needed a
counter that spans clients, since no single client's max_live can see an overlap
between two of them; six parallel closes get a Barrier(6), so a serial close
deadlocks and says so instead of merely running slowly; and the eviction test
asserts the caller returned while the victim's teardown was still running, which
is the property the 0.5s bound was standing in for.

test_stream_cancel_registration_timing.py compared two separately-taken
durations, exactly what #10868 had to remove from _growth. The two patterns
differ in chunks seen, deterministically: the blocking loop never lets the cancel
through and drains all eight, the awaiting loop stops at the first.

Four guards against a quadratic blow-up carried absolute budgets
(test_tool_xml_strip.py, test_update_release_notes.py, test_rag_store.py).
Backtracking is superlinear by definition, so growth is the property, and
#10868's paired-ratio statistics already exist for it. Lift _growth and
_assert_linear out of test_pr5624_regressions.py into tests/_shared/growth.py,
generalised over the function under measurement, next to real_accelerator.py and
for the same reason.

test_profile_stats.py and the two liveness files keep a wall-clock bound, because
"it did not block" is what they mean, but a generous one: the sharp claim in each
is already asserted next to it (the row count is zero, stop() returned False, the
stub raises if detection starts).

test_backend_ci_parallel_isolation.py scans for this shape and required three
named files to keep exhibiting it, which made it a second, invisible reason those
files could not be fixed: rewriting the vram-settle bounds failed there, in a file
about CI topology, with a message about a sample. It builds all three shapes
itself now.

Not touched: test_health_answers_within_probe_budget.py. Its bounds are the
subject, derived from the real desktop probe timeout rather than from a guess,
and it already asserts on state where state was the honest answer.

Each rewritten assertion was checked against a deliberately broken
implementation: no cold-start short-circuit, an unclipped sleep, a one-shot wait
loop, _PROBE_FANOUT of 1, _MAX_CLOSE_THREADS of 1, and two synthetic quadratic
sweeps. Full backend suite run the way CI runs it, three times: identical failure
set to main.

…chdog

Half the watchdog's probe budget is 5s, which passes a route that grew seconds of
synchronous work on the event loop. The probe snippets now serve a route that only
returns a dict through the same app and client, so both pay the same interpreter and
scheduler and what is left is the route's own cost.

The watchdog bound stays as the second half of the pair: a relative bound cannot
see an absolute timeout, since a control that took seconds would scale with it.

Half of _SESSION_CLOSE_TIMEOUT is five seconds, which passes a caller that blocks
for a second before handing the victim to the cleanup worker. The cap is now
applied after a control call on a second URL, so the two differ only in whether an
eviction happens and the claim is measured rather than budgeted.

…un, drop a live dependency

The slow-probe test asked for a nap that a correct helper need not make: if the
scheduler ate the 0.1s left of the budget it returned at the deadline check instead,
and the assertion failed on a good run. It now runs on a clock the test moves, so
the probe charges its cost instead of sleeping and every sample is exact.

growth() takes abort_over_s, so a big leg already over the backstop stops the
repeats instead of measuring the same known-bad path three times.

The parallel-isolation meta-test no longer requires the live backend suite to still
contain a fragile assertion; the synthetic files cover every shape, and that
requirement would have turned cleaning the last one into a failure.

… thread

A control taken in its own batch shares no scheduler delay with the request it is
compared against, so a pause landing on the measurement alone was not divided out
and the 50ms floor made that stricter than the bound it replaced. Both liveness
snippets now alternate control and measurement and take the best of three on each
side.

The never-settles test moves to the same fake clock as the slow-probe one: its lower
bound says the helper did not stop early, and real time spent outside sleep()
retires the deadline without appearing in the naps.

The eviction test asks which thread calls close() instead of how long the caller
took. __aexit__ cannot answer it, since that always runs on the session's own loop
thread, but the caller of close() is exactly the claim in the test's name.