0.18 primitive: rename crate::io::Writer → WritebackFile

The type's job is the bounded-cache writeback pipeline (sync_file_range
+ posix_fadvise(DONTNEED)) — not generic writing. The 0.17 name was
ambiguous; reading `Writer::new(file)` gave no hint about what was
special. New name makes the role obvious at every call site.

Adds `WritebackFile::create(path)` and `WritebackFile::open(path)`
constructors so callers don't have to assemble a `File` first.

No alias kept; this is a clean 0.18 rename. See
freemkv-private/memory/0_18_redesign.md.

Single contributor: MattJackson.

src/disc/mod.rs

@@ -1418,10 +1418,11 @@ impl Disc {
             f
         };
 
-        // Wrap the raw `File` in our bounded-cache writer (drains
-        // dirty pages continuously instead of bursting; see
-        // `crate::io`). The Writer moves into the consumer thread.
-        let file = crate::io::Writer::new(file).map_err(|e| Error::IoError { source: e })?;
+        // Wrap the raw `File` in our bounded-cache `WritebackFile`
+        // (drains dirty pages continuously instead of bursting; see
+        // `crate::io`). The `WritebackFile` moves into the consumer
+        // thread.
+        let file = crate::io::WritebackFile::new(file).map_err(|e| Error::IoError { source: e })?;
         let batch: u16 = match opts.batch_sectors {
             Some(b) => b,
             None if opts.skip_on_error => ecc_sectors(self.format),
@@ -1435,7 +1436,7 @@ impl Disc {
         // sweep finishes are the patch pass's job.
         let regions: Vec<(u64, u64)> = map.ranges_with(&[mapfile::SectorStatus::NonTried]);
 
-        // Spawn the consumer. It owns Writer + Mapfile; the producer
+        // Spawn the consumer. It owns WritebackFile + Mapfile; the producer
         // (this thread) keeps `reader`, `read_ctx`, halt + set_speed.
         let (work_tx, prog_rx, consumer_handle) = spawn_consumer(ConsumerInputs {
             file,
@@ -1978,14 +1979,11 @@ impl Disc {
         let is_regular = std::fs::metadata(path)
             .map(|m| m.file_type().is_file())
             .unwrap_or(false);
-        let file = std::fs::OpenOptions::new()
-            .write(true)
-            .open(path)
-            .map_err(|e| Error::IoError { source: e })?;
-        // Same bounded-cache writeback wrapper sweep uses, so patch's
+        // Same bounded-cache `WritebackFile` sweep uses, so patch's
         // recovery writes (sparse but can be many across a damaged region)
         // get the burst-flush protection on slow / NFS-backed staging.
-        let mut file = crate::io::Writer::new(file).map_err(|e| Error::IoError { source: e })?;
+        let mut file =
+            crate::io::WritebackFile::open(path).map_err(|e| Error::IoError { source: e })?;
 
         // Log ISO file size at patch start for write monitoring
         if let Ok(metadata) = std::fs::metadata(path) {

src/disc/sweep_pipeline.rs

@@ -9,7 +9,7 @@
 //! both costs.
 //!
 //! This module decouples them. A consumer thread owns the
-//! [`crate::io::Writer`] (the ISO file) and the
+//! [`crate::io::WritebackFile`] (the ISO file) and the
 //! [`super::mapfile::Mapfile`]. The producer thread (the caller of
 //! `Disc::sweep`) keeps the [`crate::sector::SectorReader`], the
 //! [`super::read_error`] state machine, and decrypt — so what enters
@@ -112,7 +112,7 @@ pub(super) struct ConsumerSummary {
 /// happens on the producer side before send, so the consumer never
 /// sees keys.
 pub(super) struct ConsumerInputs {
-    pub file: crate::io::Writer,
+    pub file: crate::io::WritebackFile,
     pub map: Mapfile,
     /// `sync_all`-on-failure-is-an-error iff the output is a regular
     /// file. `/dev/null` and pipes always fail `sync_all`; that's not
@@ -279,7 +279,7 @@ fn apply_item(
                 .file
                 .seek(SeekFrom::Start(pos))
                 .map_err(|e| Error::IoError { source: e })?;
-            // Subsequent writes are sequential; `crate::io::Writer`'s
+            // Subsequent writes are sequential; `crate::io::WritebackFile`'s
             // seek-elision keeps them on the writeback pipeline path.
             let mut filled = 0u64;
             while filled < len {