core: io/sparse_file + io/write_buffer (stage 4)

io/sparse_file — the single O_WRONLY output file (docs/04 §4). open()
posix_fallocate's the full size (falls back to ftruncate on
EOPNOTSUPP/ENOSYS, reported via preallocated()); write_at() pwrites at an
absolute offset, looping short writes and retrying EINTR; sync() is
fdatasync (timer/pause only); advise_dontneed() is
posix_fadvise(DONTNEED); resize() trims a preallocated tail or sizes a
chunked download. errno -> vdm::Error (ENOSPC->disk_full,
EACCES->permission_denied, ENOENT/ENOTDIR/...->path_rejected). No lock on
write_at — POSIX makes each pwrite atomic for a regular file, so N
segment threads writing disjoint ranges is safe (tested, TSan-clean).

io/write_buffer — per-segment accumulate-and-flush buffer, preallocated
at construction; append() only memcpys (no allocation on the write-
callback hot path, docs/04 §8 — asserted by a global-new counter in the
test). Flushes on fill via a caller-supplied FlushFn; a chunk >= capacity
arriving on an empty buffer writes straight through. On a flush error
next_offset() stays at the last durable position. Single-threaded; the
disk-writer-thread handoff is stage 8.

Also: vtest.hpp VT_CHECK_EQ/NE now copy operands (auto, not auto&&) — an
assertion must not outlive a temporary the expression returned a
reference into (ASan caught this on Result<void>{}.error().code).

Co-Authored-By: Claude Sonnet 5 <[email protected]>
Claude-Session: https://claude.ai/code/session_01HPPSGhiArbvQgwC2DNiURS

core/tests/support/vtest.hpp

@@ -129,11 +129,14 @@ inline int run_all() {
             ::vt::report(__FILE__, __LINE__, #COND, {}, /*fatal=*/true); \
     } while (0)
 
+// NOTE: operands are copied (auto, not auto&&). A test assertion must never outlive a
+// temporary the expression returned a reference into — the copy makes that safe. All
+// compared types here are cheap to copy.
 #define VT_CHECK_EQ(A, B)                                                  \
     do {                                                                   \
         ::vt::stats().checks++;                                            \
-        auto &&_a = (A);                                                   \
-        auto &&_b = (B);                                                   \
+        auto _a = (A);                                                     \
+        auto _b = (B);                                                     \
         if (!(_a == _b))                                                   \
             ::vt::report(__FILE__, __LINE__, #A " == " #B,                 \
                          ::vt::show(_a) + " vs " + ::vt::show(_b), false); \
@@ -142,8 +145,8 @@ inline int run_all() {
 #define VT_CHECK_NE(A, B)                                                  \
     do {                                                                   \
         ::vt::stats().checks++;                                            \
-        auto &&_a = (A);                                                   \
-        auto &&_b = (B);                                                   \
+        auto _a = (A);                                                     \
+        auto _b = (B);                                                     \
         if (!(_a != _b))                                                   \
             ::vt::report(__FILE__, __LINE__, #A " != " #B,                 \
                          ::vt::show(_a) + " vs " + ::vt::show(_b), false); \