feat(compress): move context parameter policy into Rust

Move ZSTD_CCtx_setParameter stage authorization, supported-parameter
validation, static-context worker guard, and max-block side effect into
a Rust-owned ABI bridge while retaining C-owned context and parameter
storage. Preserve update authorization and error ordering.

Test Plan:
- cargo test --manifest-path rust/Cargo.toml --lib
- cargo clippy --manifest-path rust/Cargo.toml --all-targets -- -D warnings
- make -B -C programs -j1 zstd
- make -C tests -j1 test-zstream ZSTREAM_TESTTIME=-T1s
- focused set_parameter unit tests

lib/compress/zstd_compress.c

@@ -266,6 +266,27 @@ typedef char ZSTD_rust_set_parameters_using_cctx_params_state_layout[
          && sizeof(ZSTD_rust_setParametersUsingCCtxParamsState)
                 == 4 * sizeof(void*))
         ? 1 : -1];
+typedef struct {
+    ZSTD_CCtx_params* requestedParams;
+    int streamStage;
+    int* cParamsChanged;
+    size_t staticSize;
+    unsigned* rustSimpleCompress2MaxBlockSizeSet;
+} ZSTD_rust_setParameterState;
+size_t ZSTD_rust_setParameter(const ZSTD_rust_setParameterState* state,
+                              int param, int value);
+typedef char ZSTD_rust_set_parameter_state_layout[
+        (offsetof(ZSTD_rust_setParameterState, requestedParams) == 0
+         && offsetof(ZSTD_rust_setParameterState, streamStage) == sizeof(void*)
+         && offsetof(ZSTD_rust_setParameterState, cParamsChanged)
+                == 2 * sizeof(void*)
+         && offsetof(ZSTD_rust_setParameterState, staticSize)
+                == 3 * sizeof(void*)
+         && offsetof(ZSTD_rust_setParameterState,
+                     rustSimpleCompress2MaxBlockSizeSet)
+                == 4 * sizeof(void*)
+         && sizeof(ZSTD_rust_setParameterState) == 5 * sizeof(void*))
+        ? 1 : -1];
 typedef void (*ZSTD_rust_resetCCtxClearAllDicts_f)(void* context);
 typedef size_t (*ZSTD_rust_resetCCtxResetParams_f)(void* context);
 typedef struct {
@@ -974,7 +995,6 @@ int ZSTD_rust_cctx_params_is_multithreaded(void);
 int ZSTD_rust_cctx_params_nb_workers_max(void);
 int ZSTD_rust_cctx_params_job_size_min(void);
 int ZSTD_rust_cctx_params_job_size_max(void);
-int ZSTD_rust_isUpdateAuthorized(int param);
 ZSTD_CCtx_params* ZSTD_rust_createCCtxParams(ZSTD_customMem customMem);
 size_t ZSTD_rust_freeCCtxParams(ZSTD_CCtx_params* params);
 size_t ZSTD_rust_CCtxParams_init_advanced(ZSTD_CCtx_params* cctxParams,
@@ -1873,76 +1893,17 @@ int ZSTD_rust_cctx_params_job_size_max(void)
     } while (0)
 
 
-static int ZSTD_isUpdateAuthorized(ZSTD_cParameter param)
-{
-    return ZSTD_rust_isUpdateAuthorized((int)param);
-}
-
 size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int value)
 {
+    ZSTD_rust_setParameterState state;
     DEBUGLOG(4, "ZSTD_CCtx_setParameter (%i, %i)", (int)param, value);
-    if (cctx->streamStage != zcss_init) {
-        if (ZSTD_isUpdateAuthorized(param)) {
-            cctx->cParamsChanged = 1;
-        } else {
-            RETURN_ERROR(stage_wrong, "can only set params in cctx init stage");
-    }   }
-
-    switch(param)
-    {
-    case ZSTD_c_nbWorkers:
-        RETURN_ERROR_IF((value!=0) && cctx->staticSize, parameter_unsupported,
-                        "MT not compatible with static alloc");
-        break;
-
-    case ZSTD_c_compressionLevel:
-    case ZSTD_c_windowLog:
-    case ZSTD_c_hashLog:
-    case ZSTD_c_chainLog:
-    case ZSTD_c_searchLog:
-    case ZSTD_c_minMatch:
-    case ZSTD_c_targetLength:
-    case ZSTD_c_strategy:
-    case ZSTD_c_ldmHashRateLog:
-    case ZSTD_c_format:
-    case ZSTD_c_contentSizeFlag:
-    case ZSTD_c_checksumFlag:
-    case ZSTD_c_dictIDFlag:
-    case ZSTD_c_forceMaxWindow:
-    case ZSTD_c_forceAttachDict:
-    case ZSTD_c_literalCompressionMode:
-    case ZSTD_c_jobSize:
-    case ZSTD_c_overlapLog:
-    case ZSTD_c_rsyncable:
-    case ZSTD_c_enableDedicatedDictSearch:
-    case ZSTD_c_enableLongDistanceMatching:
-    case ZSTD_c_ldmHashLog:
-    case ZSTD_c_ldmMinMatch:
-    case ZSTD_c_ldmBucketSizeLog:
-    case ZSTD_c_targetCBlockSize:
-    case ZSTD_c_srcSizeHint:
-    case ZSTD_c_stableInBuffer:
-    case ZSTD_c_stableOutBuffer:
-    case ZSTD_c_blockDelimiters:
-    case ZSTD_c_validateSequences:
-    case ZSTD_c_splitAfterSequences:
-    case ZSTD_c_blockSplitterLevel:
-    case ZSTD_c_useRowMatchFinder:
-    case ZSTD_c_deterministicRefPrefix:
-    case ZSTD_c_prefetchCDictTables:
-    case ZSTD_c_enableSeqProducerFallback:
-    case ZSTD_c_maxBlockSize:
-    case ZSTD_c_repcodeResolution:
-        break;
-
-    default: RETURN_ERROR(parameter_unsupported, "unknown parameter");
-    }
-    {   size_t const result = ZSTD_CCtxParams_setParameter(&cctx->requestedParams, param, value);
-        if (!ZSTD_isError(result) && param == ZSTD_c_maxBlockSize) {
-            cctx->rustSimpleCompress2MaxBlockSizeSet = 1;
-        }
-        return result;
-    }
+    state.requestedParams = &cctx->requestedParams;
+    state.streamStage = (int)cctx->streamStage;
+    state.cParamsChanged = &cctx->cParamsChanged;
+    state.staticSize = cctx->staticSize;
+    state.rustSimpleCompress2MaxBlockSizeSet =
+            &cctx->rustSimpleCompress2MaxBlockSizeSet;
+    return ZSTD_rust_setParameter(&state, (int)param, value);
 }
 
 size_t ZSTD_CCtx_getParameter(ZSTD_CCtx const* cctx, ZSTD_cParameter param, int* value)