Tracking Cycle 3 of the block crate refactoring.
See #7560 for the overall strategy discussion,
#7694 for Cycle 1, and
#7877 for Cycle 2.

RFC: https://github.com/weltling/cloud-hypervisor/blob/rfc-block-refactoring/docs/rfcs/block-refactoring-async-early.md

Background

Cycle 1 established the QCOW2 foundation:

• BlockError unified error type (block/src/error.rs)
• Composable trait hierarchy (DiskFile, AsyncDiskFile in block/src/disk_file.rs)
• QcowMetadata with coarse RwLock, ClusterReadMapping/ClusterWriteMapping
• QcowDiskSync and QcowDiskAsync migrated to new traits
• QcowAsync io_uring backend: single allocated cluster reads go through
  io_uring; multi mapping reads, compressed reads, backing file reads, and
  all writes fall back to synchronous I/O with synthetic completions

Cycle 2 expanded the proven patterns to all formats:

• All format errors migrated to BlockError at the public API boundary
• All formats implement disk_file::DiskFile / AsyncDiskFile
• RawDisk and VhdDisk unified from duplicate structs
• IoUringContext shared infrastructure in io/io_uring.rs
• Factory pattern (open_disk_file) replaces manual construction in vmm/
• DiskBackend transitional enum and async_io::DiskFile removed
• Module reorganization under formats/ and io/

Cycle 3 completes the async story for QCOW2 (writes, compressed reads,
multi mapping reads, async fsync) and extends async support to VHDx, the
last format without an async I/O path.

Phase 4: Async Writes & Completion

4.1 QCOW2 Async Writes

QcowAsync currently falls back to synchronous cow_write_sync() with
synthetic completions for all writes. This section replaces the sync
fallback with a true async write path using io_uring.

Write complexity by case (simplest to hardest):

1. Already allocated cluster: map_cluster_for_write returns
   Allocated { offset } with no metadata mutation needed. Direct
   io_uring Writev at host offset. One async operation.
2. Unallocated cluster, no backing file: metadata allocates a fresh
   cluster (L2 update + refcount) under a write lock, then returns
   Allocated { offset } for the new cluster. io_uring Writev to
   the new offset. One async operation; metadata completes before
   submission.
3. Unallocated cluster with backing file (COW): read original data
   from backing file, merge guest write data into cluster buffer,
   allocate new cluster in metadata, io_uring Writev merged data.
   Backing read is synchronous today (backing files expose
   BackingRead::read_at). The write itself goes through io_uring.

In all three cases map_cluster_for_write already handles cluster
allocation and L2/refcount updates under the metadata lock (Cycle 1
design). The caller receives a host offset and performs data I/O
without holding the lock. This means the io_uring submission path is
structurally the same as reads: resolve offset, submit, drain CQ.

The state machine complexity described in the RFC assumed metadata
mutation would need async I/O. Because QcowMetadata resolves all
metadata synchronously under a write lock and returns a plain host
offset, writes become one async operation per cluster region (after
the synchronous metadata step). The complexity therefore shifts to
multi cluster writes, where a single guest request spans several
cluster boundaries and produces multiple io_uring submissions that
must all complete before the guest request is signalled done.

4.1.1 through 4.1.3 are sequential (each extends the previous).
4.1.4 depends on 4.1.3. 4.1.5 is independent of 4.1.4 but requires
4.1.3. 4.1.6 is the synchronization point.

Acceptance criteria for 4.1:

QcowAsync.write_vectored() submits data writes to io_uring instead of
falling back to cow_write_sync. Single cluster writes complete in one
async operation. Multi cluster writes track all sub operations and fire
the guest completion only when all finish. fsync submits
IORING_OP_FSYNC to io_uring for the data file. All existing QCOW2
write tests pass unchanged. No data corruption under concurrent multi
queue writes (verified by read back tests).

4.2 QCOW2 Async Multi Mapping Reads

QcowAsync::resolve_read currently falls back to scatter_read_sync
whenever map_clusters_for_read returns more than one mapping or returns
a mapping that is not a single allocated cluster (compressed, backing,
zero). This covers three distinct fallback cases. 4.2.1 handles the multi
mapping read; 4.2.2 handles compressed clusters; 4.2.3 handles backing
file reads. 4.2.4 is the synchronization point for tests.

Acceptance criteria for 4.2:

Reads spanning multiple clusters submit per cluster io_uring operations
for Allocated regions instead of falling back to scatter_read_sync.
Zero regions are filled inline without I/O. Compressed and backing reads
use async I/O where feasible (RAW backing) or remain sync with clear
justification. Guest completion fires only after all sub reads finish.

4.3 VHDx Async Support

Cycle 2 migrated VhdxDiskSync to the new trait hierarchy but deferred
AsyncDiskFile implementation. VHDx follows the QCOW2 pattern: shared
metadata with interior mutability, per queue async I/O worker using
IoUringContext.

VHDx is simpler than QCOW2: no compression, no backing files, no COW.
The BAT (Block Allocation Table) maps virtual block addresses to host
file offsets. Metadata is read heavy and suits the same RwLock pattern
established by QcowMetadata.

4.3.1 and 4.3.2 are sequential. 4.3.3 depends on 4.3.2. 4.3.4 is the
synchronization point.

Acceptance criteria for 4.3:

VhdxDiskAsync implements AsyncDiskFile. VhdxAsync worker uses
IoUringContext from io/io_uring.rs. Factory returns VhdxDiskAsync
when io_uring is available and format is VHDx. All existing VHDx tests
pass unchanged. No &mut self on read path methods.

4.4 Cleanup

Acceptance criteria for 4.4:

No #[deprecated] attributes in block/. QcowAsync sync fallback
code is either removed or documented with justification.
cargo doc --document-private-items shows clean module boundaries.

4.5 Benchmarks & Documentation

Acceptance criteria for 4.5:

fio benchmarks show async write improvement over sync baseline.
fdatasync latency measurably improved with async fsync path. Integration
tests cover full VM lifecycle with async QCOW2 and VHDx. Every block/
module has //! documentation. Architecture decision records in docs/.

Success Criteria