feat(cli): move source file opening leaf to Rust

Keep FIO_openSrcFile's stdin sentinel handling, Windows binary-mode setup,
existing diagnostics, and FILE ownership in the C wrapper while moving only
non-stdin source validation and opening behind the Rust CLI ABI. The Rust leaf
returns distinct stat, non-regular, and fopen failure statuses, delegates
metadata and regular/FIFO/block-device classification to the existing utility
ABI, and passes the original C path directly to fopen("rb"). Opaque stat_t and
FILE* pointers cross the boundary, and the output stream is published only on
success; Rust never closes a returned stream.

Focused backend tests cover regular-file reads, missing and directory paths,
unchanged output pointers on failure, empty and spaced paths, and symlinks.
FIFO acceptance remains in the preserved classification order without a test
that could block while opening a named pipe.

Test Plan:
- `cargo test --manifest-path rust/cli/Cargo.toml --no-default-features --features cli,compression,decompression --lib fileio_backend` -- 22 passed
- CLI clippy for library, benches, and tests with `cli,compression,decompression,benchmark`, before and after nightly formatting -- clean after the new-code warnings were fixed
- `cargo +nightly fmt --manifest-path rust/cli/Cargo.toml --all -- --check` -- passed
- Root Rust clippy with the reduced `compression` feature split for library, benches, and tests -- passed with one pre-existing warning in forbidden `rust/src/zstd_compress.rs`
- `make -B -C programs -j2 zstd` -- passed
- `make -B -C programs -j2 zstd-small zstd-frugal zstd-dictBuilder` -- passed with existing unused-function warnings in compact CLI builds
- `make -C tests -j2 test-cli-tests` -- all 41 CLI tests passed, including file-stat coverage
- `make -C tests -j2 test-zstd` -- reached dictionary training, then hit a segmentation fault in the unrelated concurrent compressor/dictionary path
- `git diff --check` and `git diff --cached --check` -- passed

programs/fileio.c

@@ -351,6 +351,16 @@ int FIO_rust_adjustMemLimitForPatchFromMode(FIO_prefs_t* prefs,
                                              unsigned long long dictSize,
                                              unsigned long long maxSrcFileSize);
 int FIO_rust_getDictFileStat(const char* fileName, stat_t* statBuf);
+enum {
+    FIO_RUST_OPEN_SRC_SUCCESS = 0,
+    FIO_RUST_OPEN_SRC_STAT_FAILED = 1,
+    FIO_RUST_OPEN_SRC_NON_REGULAR = 2,
+    FIO_RUST_OPEN_SRC_FOPEN_FAILED = 3,
+};
+int FIO_rust_openSrcFile(int allowBlockDevices,
+                         const char* srcFileName,
+                         stat_t* statbuf,
+                         FILE** outFile);
 int FIO_rust_setDictBufferMalloc(const char* fileName,
                                  unsigned long long expectedFileSize,
                                  size_t maxSize,
@@ -413,24 +423,29 @@ static FILE* FIO_openSrcFile(const FIO_prefs_t* const prefs, const char* srcFile
         return stdin;
     }
 
-    if (!UTIL_stat(srcFileName, statbuf)) {
-        DISPLAYLEVEL(1, "zstd: can't stat %s : %s -- ignored \n",
-                        srcFileName, strerror(errno));
-        return NULL;
-    }
+    {   FILE* f = NULL;
+        int const status = FIO_rust_openSrcFile(allowBlockDevices,
+                                                srcFileName,
+                                                statbuf,
+                                                &f);
+        if (status == FIO_RUST_OPEN_SRC_STAT_FAILED) {
+            DISPLAYLEVEL(1, "zstd: can't stat %s : %s -- ignored \n",
+                            srcFileName, strerror(errno));
+            return NULL;
+        }
 
-    if (!UTIL_isRegularFileStat(statbuf)
-     && !UTIL_isFIFOStat(statbuf)
-     && !(allowBlockDevices && UTIL_isBlockDevStat(statbuf))
-    ) {
-        DISPLAYLEVEL(1, "zstd: %s is not a regular file -- ignored \n",
-                        srcFileName);
-        return NULL;
-    }
+        if (status == FIO_RUST_OPEN_SRC_NON_REGULAR) {
+            DISPLAYLEVEL(1, "zstd: %s is not a regular file -- ignored \n",
+                            srcFileName);
+            return NULL;
+        }
 
-    {   FILE* const f = fopen(srcFileName, "rb");
-        if (f == NULL)
+        if (status == FIO_RUST_OPEN_SRC_FOPEN_FAILED) {
             DISPLAYLEVEL(1, "zstd: %s: %s \n", srcFileName, strerror(errno));
+            return NULL;
+        }
+
+        assert(status == FIO_RUST_OPEN_SRC_SUCCESS);
         return f;
     }
 }