feat: initial implementation of content-addressed incremental backup engine

Rust-centric architecture with TypeScript facade following smartproxy/smartstorage pattern.
Core engine in Rust (FastCDC chunking, SHA-256, gzip, AES-256-GCM + Argon2id, binary pack files,
global index, snapshots, locking, verification, pruning, repair). TypeScript provides npm interface
via @push.rocks/smartrust RustBridge IPC with Unix socket streaming for ingest/restore.
All 14 integration tests pass.

rust/src/compression.rs

@@ -0,0 +1,43 @@
+use flate2::Compression;
+use flate2::read::{GzDecoder, GzEncoder};
+use std::io::Read;
+use crate::error::ArchiveError;
+
+/// Gzip compress data.
+pub fn compress(data: &[u8]) -> Result<Vec<u8>, ArchiveError> {
+    let mut encoder = GzEncoder::new(data, Compression::default());
+    let mut compressed = Vec::new();
+    encoder.read_to_end(&mut compressed)
+        .map_err(|e| ArchiveError::Io(e))?;
+    Ok(compressed)
+}
+
+/// Gzip decompress data.
+pub fn decompress(data: &[u8]) -> Result<Vec<u8>, ArchiveError> {
+    let mut decoder = GzDecoder::new(data);
+    let mut decompressed = Vec::new();
+    decoder.read_to_end(&mut decompressed)
+        .map_err(|e| ArchiveError::Io(e))?;
+    Ok(decompressed)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_roundtrip() {
+        let data = b"Hello, this is test data for compression!";
+        let compressed = compress(data).unwrap();
+        let decompressed = decompress(&compressed).unwrap();
+        assert_eq!(data.as_slice(), decompressed.as_slice());
+    }
+
+    #[test]
+    fn test_compression_reduces_size() {
+        // Highly compressible data
+        let data = vec![b'A'; 10000];
+        let compressed = compress(&data).unwrap();
+        assert!(compressed.len() < data.len());
+    }
+}