refactor(mt): move stream input copy into Rust

The MT streaming scheduler previously delegated each bounded input-buffer copy
through a C-only callback. That callback mutated the C context as a side
effect, which kept a trivial data movement operation outside the Rust stream
path and made the result projection incomplete.

Copy the checked input range directly in Rust with copy_nonoverlapping, after
the existing available-input, destination-capacity, and non-null-source checks.
The C input-range callback remains responsible for exposing the reusable buffer,
while the Rust result now returns its updated filled count. C publishes that
count back to mtctx after the scheduler call. The result ABI has explicit
cross-language layout assertions, and the scheduler test verifies both copied
bytes and fill accounting. Job scheduling and all other MT callbacks are
unchanged.

Test Plan:
- `cc -fsyntax-only -Werror=incompatible-pointer-types -Ilib -Ilib/common -Ilib/compress -Ilib/decompress -Ilib/dict -Ilib/legacy lib/compress/zstdmt_compress.c` -- passed
- `cargo +nightly fmt --manifest-path rust/Cargo.toml --all -- --check` -- passed
- `git diff --check` and `git diff --cached --check` -- passed
- Cargo build/test, make, fuzzers, and other heavy checks were not run per task instructions

lib/compress/zstdmt_compress.c

@@ -17,7 +17,7 @@
 
 /* ======   Dependencies   ====== */
 #include "../common/allocations.h" /* ZSTD_customMalloc, ZSTD_customCalloc, ZSTD_customFree */
-#include "../common/zstd_deps.h"   /* ZSTD_memcpy, ZSTD_memset, INT_MAX, UINT_MAX */
+#include "../common/zstd_deps.h"   /* ZSTD_memmove, ZSTD_memset, INT_MAX, UINT_MAX */
 #include "../common/mem.h"         /* MEM_STATIC */
 #include "../common/pool.h"        /* threadpool */
 #include "../common/threading.h"   /* mutex */
@@ -381,10 +381,18 @@ typedef struct {
     size_t result;
     size_t inputPos;
     size_t outputPos;
+    size_t inBuffFilled;
 } ZSTDMT_RustCompressStreamResult;
+typedef char ZSTDMT_compress_stream_result_layout[
+        (offsetof(ZSTDMT_RustCompressStreamResult, result) == 0
+         && offsetof(ZSTDMT_RustCompressStreamResult, inputPos) == sizeof(size_t)
+         && offsetof(ZSTDMT_RustCompressStreamResult, outputPos) == 2 * sizeof(size_t)
+         && offsetof(ZSTDMT_RustCompressStreamResult, inBuffFilled)
+                == 3 * sizeof(size_t)
+         && sizeof(ZSTDMT_RustCompressStreamResult) == 4 * sizeof(size_t))
+        ? 1 : -1];
 typedef int (*ZSTDMT_streamTryGetInputRangeFn)(
         void* opaque, ZSTDMT_RustStreamInputRangeProjection* projection);
-typedef int (*ZSTDMT_streamLoadInputFn)(void* opaque, const void* src, size_t size);
 typedef size_t (*ZSTDMT_streamCreateJobFn)(void* opaque, size_t srcSize, unsigned end);
 typedef ZSTDMT_RustStreamFlushResult (*ZSTDMT_streamFlushProducedFn)(
         void* opaque, void* outputDst, size_t outputSize, size_t outputPos,
@@ -395,7 +403,6 @@ ZSTDMT_RustCompressStreamResult ZSTDMT_rust_compressStreamGeneric(
         const ZSTDMT_RustStreamOutputProjection* output,
         unsigned end, void* opaque,
         ZSTDMT_streamTryGetInputRangeFn tryGetInputRange,
-        ZSTDMT_streamLoadInputFn loadInput,
         ZSTDMT_streamCreateJobFn createJob,
         ZSTDMT_streamFlushProducedFn flushProduced);
 
@@ -3041,17 +3048,6 @@ static int ZSTDMT_streamTryGetInputRange(
     return ready;
 }
 
-static int ZSTDMT_streamLoadInput(void* opaque, const void* src, size_t size)
-{
-    ZSTDMT_CCtx* const mtctx = (ZSTDMT_CCtx*)opaque;
-    assert(mtctx->inBuff.buffer.start != NULL);
-    assert(mtctx->inBuff.filled <= mtctx->inBuff.buffer.capacity);
-    assert(size <= mtctx->inBuff.buffer.capacity - mtctx->inBuff.filled);
-    ZSTD_memcpy((char*)mtctx->inBuff.buffer.start + mtctx->inBuff.filled, src, size);
-    mtctx->inBuff.filled += size;
-    return 1;
-}
-
 size_t ZSTDMT_nextInputSizeHint(const ZSTDMT_CCtx* mtctx)
 {
     return ZSTDMT_rust_nextInputSizeHint(mtctx->targetSectionSize,
@@ -3091,13 +3087,14 @@ size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,
     ZSTDMT_RustCompressStreamResult const result =
         ZSTDMT_rust_compressStreamGeneric(
             &context, &inputProjection, &outputProjection, (unsigned)endOp,
-            mtctx, ZSTDMT_streamTryGetInputRange, ZSTDMT_streamLoadInput,
+            mtctx, ZSTDMT_streamTryGetInputRange,
             ZSTDMT_createCompressionJob, ZSTDMT_streamFlushProduced);
 
     DEBUGLOG(5, "ZSTDMT_compressStream_generic (endOp=%u, srcSize=%u)",
                 (U32)endOp, (U32)(input->size - input->pos));
     assert(output->pos <= output->size);
     assert(input->pos  <= input->size);
+    mtctx->inBuff.filled = result.inBuffFilled;
     input->pos = result.inputPos;
     output->pos = result.outputPos;
     DEBUGLOG(5, "end of ZSTDMT_compressStream_generic: remainingToFlush = %u", (U32)result.result);