Make DataCache Sendable and drain it with a single writer task

[kean]

DataCache was the last type in the library still coordinating its work with GCD: a serial DispatchQueue, an NSLock for the staging area, asyncAfter for the flush and sweep timers, and @unchecked Sendable to paper over the rest.

It now keeps all of its mutable state – the staging area and the configuration – behind a single OSAllocatedUnfairLock, which makes it Sendable. The 1-second flush timer is replaced by a single self-terminating writer Task that drains the staging area in a loop, so the writes still batch up under load but reach the disk in milliseconds, and there is no timer state to race on.

The blocking file operations run on a serial dispatch queue. Doing them in a task would occupy a cooperative pool thread for the whole duration of a write, so the writer hops into the queue once and drains everything there – blocking work is what GCD threads are for. The queue is .default, not .utility: a block submitted with async never gets its priority escalated, unlike the queue.sync the cache used before, so at .utility the caller of flush() waits on throttled I/O.

Two bugs fixed along the way:

• Data races on the configuration. sizeLimit, sweepInterval, isSweepEnabled, and trimRatio were plain vars written by the client and read from the I/O queue. They now live in the locked State; sweepDelay and onSweepCompleted became let, since only the internal test initializer ever set them.
• init performed disk I/O on the calling thread. scheduleSweep() read and JSON-decoded .data-cache-info before returning, i.e. on the main thread for ImagePipeline.Configuration.withDataCache. The check moved into the writer, so onSweepCompleted now also fires only when a sweep actually runs.

One more trap worth recording: Task.sleep at .background priority is subject to timer coalescing, and scheduledSweepUpdatesMetadata went from 0.034s to 11.7s. The sweep task runs at .utility, with a comment explaining why.

Breaking: DataCache.flush() and DataCache.sweep() are now async. DataCache.flush(for:) and DataCache.queue are removed – the queue is an implementation detail now. DataCacheTests used queue to suspend the I/O, so withSuspendedIO moved into the source as an internal test hook.

The DataCaching protocol and the staging area are unchanged. The per-change IDs in the staging area look like ceremony, but they are what lets the writer drop the state lock while writing and then remove only the entries that weren't replaced meanwhile — that's the property that keeps reads parallel to writes.

To test

1. Run the NukeTests scheme – 991 tests pass, including all 47 DataCacheTests.
2. Run the NukeThreadSafetyTests scheme – 7 tests pass.
3. Run NukePerformanceTests/DataCachePeformanceTests – the write benchmarks are unchanged.