fix(build): repair fuzz target and wasm decoder after upstream refactors

Two build breaks landed on main today and redden every PR that touches the
fuzz path-filtered crates:

- 637feea (refactor(mem): mandatory ScopedMemory) replaced
  SegmentWriter::plain() with SegmentWriter::new(profile_tag, ScopedMemory).
  The fuzz columnar_segment target still called the removed constructor.
  Adapt it to the new API with a governor-backed scope (the shape the
  columnar integration tests use) and the PROFILE_PLAIN tag, matching the
  production call sites in columnar_checkpoint/load.rs.

- The workspace ruzstd bump 0.7 -> 0.9 moved the streaming decoder out of
  the crate root (it is re-exported from ruzstd::decoding). The WASM
  decompression path in nodedb-codec still imported ruzstd::StreamingDecoder,
  which no longer resolves — the 32-bit build check failed on it.

Verified locally: `cargo build --manifest-path fuzz/Cargo.toml` on nightly
compiles clean; nodedb-codec clippy is clean. The wasm32 check itself needs
the CI runner's getrandom artifact cache (plain getrandom 0.3 lacks the
wasm_js feature outside the aliased getrandom_03 entry), so it re-verifies
in the 32-bit build check job.

Author: EnRaiha

fuzz/Cargo.lock

@@ -16,6 +16,7 @@ libfuzzer-sys = { version = "0.4", optional = true }
 tempfile = "3"
 nodedb-codec = { path = "../nodedb-codec" }
 nodedb-columnar = { path = "../nodedb-columnar" }
+nodedb-mem = { path = "../nodedb-mem" }
 nodedb-strict = { path = "../nodedb-strict" }
 nodedb-types = { path = "../nodedb-types" }
 nodedb-wal = { path = "../nodedb-wal" }

fuzz/Cargo.toml

@@ -1,8 +1,13 @@
+use std::sync::Arc;
+
 use nodedb_columnar::memtable::ColumnData;
+use nodedb_columnar::writer::PROFILE_PLAIN;
 use nodedb_columnar::{
     DeleteBitmap, OwnedSegmentReader, ScanPredicate, SegmentReader, SegmentWriter,
 };
+use nodedb_mem::{EngineId, EngineLimits, GovernorConfig, MemoryGovernor, ScopedMemory};
 use nodedb_types::columnar::{ColumnDef, ColumnType, ColumnarSchema};
+use nodedb_types::{DatabaseId, TenantId};
 use nodedb_wal::crypto::WalEncryptionKey;
 
 const INPUT_PREFIX_BYTES: usize = 64;
@@ -17,6 +22,26 @@ const COLUMN_COUNT: usize = 5;
 const FUZZ_KEK_BYTES: [u8; 32] = [0x5a; 32];
 const FUZZ_KEK_EPOCH: [u8; 4] = [0; 4];
 
+/// A memory scope whose governor ceiling covers every engine's limit — the
+/// same shape the integration tests use. Segment writes now take mandatory
+/// ScopedMemory (refactor(mem): make ScopedMemory budgeting mandatory).
+fn fuzz_memory() -> ScopedMemory {
+    let per_engine = usize::MAX / EngineId::ALL.len();
+    let governor = Arc::new(
+        MemoryGovernor::new(GovernorConfig {
+            global_ceiling: per_engine * EngineId::ALL.len(),
+            engine_limits: EngineLimits::uniform(per_engine),
+        })
+        .expect("fuzz governor"),
+    );
+    ScopedMemory::new(
+        governor,
+        DatabaseId::DEFAULT,
+        TenantId::new(0),
+        EngineId::Columnar,
+    )
+}
+
 fn exercise_reader(reader: &SegmentReader<'_>) {
     let count = reader.column_count().min(COLUMN_COUNT);
     for index in 0..count {
@@ -169,7 +194,7 @@ fn generated_segment(seed: &[u8], kek: Option<&WalEncryptionKey>) -> Option<Vec<
         },
     ];
 
-    SegmentWriter::plain()
+    SegmentWriter::new(PROFILE_PLAIN, fuzz_memory())
         .write_segment(&schema, &columns, ROW_COUNT, kek)
         .ok()
 }

fuzz/src/targets/columnar_segment.rs

@@ -321,7 +321,7 @@ fn compress_native(_data: &[u8], _level: i32) -> Result<Vec<u8>, CodecError> {
 
 #[cfg(target_arch = "wasm32")]
 fn decompress_native(frame: &[u8], expected_size: usize) -> Result<Vec<u8>, CodecError> {
-    use ruzstd::StreamingDecoder;
+    use ruzstd::decoding::StreamingDecoder;
 
     let mut decoder = StreamingDecoder::new(std::io::Cursor::new(frame)).map_err(|e| {
         CodecError::DecompressFailed {