fix: writer preference so budget-monopolizing copies are not starved

[ServerSideHannes]

Problem

Prod logs showed a server-side COPY stuck on endless MEMORY_BACKPRESSURE with requested_mb == limit_mb:

{"active_mb": 8.38, "requested_mb": 192.0, "limit_mb": 192.0, "remaining_sec": 6.7, "event": "MEMORY_BACKPRESSURE"}

A multi-GB manifest COPY deliberately clamps its reservation to the whole budget so it runs exclusively — this is the guard against the 3×4.7GB concurrent-copy OOM that #110 fixed (tests/unit/test_copy_clamp_and_concurrency.py). That part is correct and unchanged.

The bug is in the limiter's admission logic. The gate is active_bytes + to_reserve <= limit, so a whole-budget reservation can only be admitted when active_bytes == 0. The limiter had no fairness: every release() does notify_all(), and a small request re-grabs memory before the waiting copy can (it fits), so active_bytes never drains to 0 under steady backup traffic. The copy backpressures the full BACKPRESSURE_TIMEOUT, 503s, retries, starves again — functionally never admitted while the pod has any other traffic.

Fix

Writer preference, not a smaller clamp (lowering the clamp would re-introduce the multi-copy OOM). Track pending whole-budget ("exclusive") waiters; while one waits, hold back new non-exclusive admissions so active_bytes drains to 0 and the copy gets its exclusive slot — bounded by the lifetime of the already-running requests. Copies still reserve the whole budget and run one-at-a-time.

• _can_admit(to_reserve, exclusive): an exclusive request ignores the pending gate (competes only on active_bytes == 0); a non-exclusive request also waits while _pending_exclusive > 0.
• _pending_exclusive incremented/decremented around the wait, with a notify_all() on exit so held-back requests resume whether the copy acquired or gave up.

Tests

All existing copy-concurrency / OOM regression tests are unchanged and pass (copies still exclusive, still one-at-a-time).

Added test_pending_exclusive_copy_not_starved_by_small_requests: a pending exclusive copy must not be starved by a stream of small requests — they queue behind it, and the copy wins the slot the moment the in-flight blocker drains. Verified it fails against the old no-fairness limiter with the exact prod signature (requested_mb == limit_mb backpressure while a small request slips ahead), and passes with writer preference.