fix(rust): restore D7/D8/D10 streaming trait adapters

Restores spec compliance for Rust streaming API requirements D7/D8/D10
by reintroducing StreamingEncoder/StreamingDecoder wrappers for Huffman,
Arithmetic, and RLE algorithms.

Previous commit 31b8b2f removed too much - it correctly eliminated
duplicate src/bin/*.rs files and lib_base.rs, but also removed the
streaming trait implementations required by the spec.

Changes:
- Add StreamingEncoder/StreamingDecoder to huffman/rust/src/lib.rs
- Add StreamingEncoder/StreamingDecoder to arithmetic/rust/src/lib.rs
- Add StreamingEncoder/StreamingDecoder to rle/rust/src/lib.rs
- Add compresskit-codec dependency to all three algorithm crates
- Add integration tests in shared/rust/tests/lifecycle.rs that verify:
  * All algorithms implement Encoder/Decoder traits
  * Roundtrip encode/decode works via trait objects

Implementation uses buffered wrapper strategy (not incremental codec):
- process() accumulates input in memory buffer
- flush() transitions state but produces no output
- finish() performs full encode/decode and writes to output buffer
- Follows exact same pattern as range/rust reference implementation

Scope preserved:
- NO src/bin/*.rs duplicates reintroduced
- NO lib_base.rs duplicates reintroduced
- main.rs remains CLI source of truth

Tests:
- cargo test --manifest-path algorithms/shared/rust/Cargo.toml
  All 9 tests pass (lifecycle + integration)
- cargo build for huffman/arithmetic/rle: all succeed

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: LessUp

algorithms/arithmetic/rust/Cargo.lock

@@ -8,4 +8,7 @@ rust-version = "1.70"
 name = "arithmetic"
 path = "src/lib.rs"
 
+[dependencies]
+compresskit-codec = { path = "../../shared/rust" }
+
 [dev-dependencies]

algorithms/arithmetic/rust/Cargo.toml

@@ -234,3 +234,193 @@ pub fn decode(input: &[u8]) -> Result<Vec<u8>, io::Error> {
 
     Ok(output)
 }
+
+// Streaming adapters
+use compresskit_codec::codec::{CodecError, Decoder as CodecDecoder, Encoder as CodecEncoder, State};
+
+fn io_error_to_codec_error(e: io::Error) -> CodecError {
+    match e.kind() {
+        io::ErrorKind::UnexpectedEof => CodecError::Truncated,
+        io::ErrorKind::InvalidData => {
+            let msg = e.to_string();
+            if msg.contains("truncated") || msg.contains("too short") {
+                CodecError::Truncated
+            } else if msg.contains("invalid") || msg.contains("bad") {
+                CodecError::Corrupt
+            } else {
+                CodecError::Other(msg)
+            }
+        }
+        _ => CodecError::Other(e.to_string()),
+    }
+}
+
+pub struct StreamingEncoder {
+    state: State,
+    buffer: Vec<u8>,
+}
+
+impl StreamingEncoder {
+    pub fn new() -> Self {
+        StreamingEncoder {
+            state: State::Ready,
+            buffer: Vec::new(),
+        }
+    }
+}
+
+impl Default for StreamingEncoder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl CodecEncoder for StreamingEncoder {
+    fn process(&mut self, input: &[u8], _output: &mut [u8]) -> Result<usize, CodecError> {
+        match self.state {
+            State::Ready | State::Flushing => {
+                self.state = State::Streaming;
+                self.buffer.extend_from_slice(input);
+                Ok(0)
+            }
+            State::Streaming => {
+                self.buffer.extend_from_slice(input);
+                Ok(0)
+            }
+            State::Finished => {
+                self.state = State::Error;
+                Err(CodecError::InvalidState)
+            }
+            State::Error => Err(CodecError::InvalidState),
+        }
+    }
+
+    fn flush(&mut self, _output: &mut [u8]) -> Result<usize, CodecError> {
+        match self.state {
+            State::Ready => Ok(0),
+            State::Streaming => {
+                self.state = State::Flushing;
+                Ok(0)
+            }
+            State::Flushing => Ok(0),
+            State::Finished => {
+                self.state = State::Error;
+                Err(CodecError::InvalidState)
+            }
+            State::Error => Err(CodecError::InvalidState),
+        }
+    }
+
+    fn finish(&mut self, output: &mut [u8]) -> Result<usize, CodecError> {
+        match self.state {
+            State::Ready | State::Streaming | State::Flushing => {
+                let encoded = encode(&self.buffer).map_err(io_error_to_codec_error)?;
+                if output.len() < encoded.len() {
+                    return Err(CodecError::BufTooSmall);
+                }
+                output[..encoded.len()].copy_from_slice(&encoded);
+                self.state = State::Finished;
+                Ok(encoded.len())
+            }
+            State::Finished => {
+                self.state = State::Error;
+                Err(CodecError::InvalidState)
+            }
+            State::Error => Err(CodecError::InvalidState),
+        }
+    }
+
+    fn reset(&mut self) {
+        self.state = State::Ready;
+        self.buffer.clear();
+    }
+
+    fn state(&self) -> State {
+        self.state
+    }
+}
+
+pub struct StreamingDecoder {
+    state: State,
+    buffer: Vec<u8>,
+}
+
+impl StreamingDecoder {
+    pub fn new() -> Self {
+        StreamingDecoder {
+            state: State::Ready,
+            buffer: Vec::new(),
+        }
+    }
+}
+
+impl Default for StreamingDecoder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl CodecDecoder for StreamingDecoder {
+    fn process(&mut self, input: &[u8], _output: &mut [u8]) -> Result<usize, CodecError> {
+        match self.state {
+            State::Ready | State::Flushing => {
+                self.state = State::Streaming;
+                self.buffer.extend_from_slice(input);
+                Ok(0)
+            }
+            State::Streaming => {
+                self.buffer.extend_from_slice(input);
+                Ok(0)
+            }
+            State::Finished => {
+                self.state = State::Error;
+                Err(CodecError::InvalidState)
+            }
+            State::Error => Err(CodecError::InvalidState),
+        }
+    }
+
+    fn flush(&mut self, _output: &mut [u8]) -> Result<usize, CodecError> {
+        match self.state {
+            State::Ready => Ok(0),
+            State::Streaming => {
+                self.state = State::Flushing;
+                Ok(0)
+            }
+            State::Flushing => Ok(0),
+            State::Finished => {
+                self.state = State::Error;
+                Err(CodecError::InvalidState)
+            }
+            State::Error => Err(CodecError::InvalidState),
+        }
+    }
+
+    fn finish(&mut self, output: &mut [u8]) -> Result<usize, CodecError> {
+        match self.state {
+            State::Ready | State::Streaming | State::Flushing => {
+                let decoded = decode(&self.buffer).map_err(io_error_to_codec_error)?;
+                if output.len() < decoded.len() {
+                    return Err(CodecError::BufTooSmall);
+                }
+                output[..decoded.len()].copy_from_slice(&decoded);
+                self.state = State::Finished;
+                Ok(decoded.len())
+            }
+            State::Finished => {
+                self.state = State::Error;
+                Err(CodecError::InvalidState)
+            }
+            State::Error => Err(CodecError::InvalidState),
+        }
+    }
+
+    fn reset(&mut self) {
+        self.state = State::Ready;
+        self.buffer.clear();
+    }
+
+    fn state(&self) -> State {
+        self.state
+    }
+}

algorithms/arithmetic/rust/src/lib.rs

@@ -8,4 +8,7 @@ rust-version = "1.70"
 name = "huffman"
 path = "src/lib.rs"
 
+[dependencies]
+compresskit-codec = { path = "../../shared/rust" }
+
 [dev-dependencies]