Implement Week 4 CAS store with chunk deduplication and LRU eviction

- Add musicfs-cas crate: CasStore, ChunkHash, FileReader, ChunkManifest
- Add LruEviction policy to musicfs-cache for cache size management
- Integrate FileReader into FUSE filesystem for actual file reads
- Use xxHash64 for content hashing, sled for index, msgpack serialization
- Default cache path: ~/.cache/musicfs/chunks/ with 256 subdirs sharding
- 20 new tests (14 CAS unit + 3 integration + 3 eviction), 54 total

musicfs/crates/musicfs-cas/tests/integration.rs

@@ -0,0 +1,100 @@
+use musicfs_cache::TreeBuilder;
+use musicfs_cas::{CasConfig, CasStore, ChunkManifest, ChunkRef, FileReader};
+use musicfs_core::{FileId, FileMeta, OriginId, RealPath, VirtualPath};
+use std::path::PathBuf;
+use std::sync::{Arc, RwLock};
+use std::time::SystemTime;
+use tempfile::TempDir;
+
+fn make_file_meta(id: i64, vpath: &str, size: u64) -> FileMeta {
+    FileMeta {
+        id: FileId(id),
+        virtual_path: VirtualPath::new(vpath),
+        real_path: RealPath {
+            origin_id: OriginId::from("test"),
+            path: PathBuf::from("/test"),
+        },
+        size,
+        mtime: SystemTime::now(),
+        content_hash: None,
+        audio: None,
+    }
+}
+
+#[tokio::test]
+async fn test_cas_and_tree_integration() {
+    let dir = TempDir::new().unwrap();
+    let config = CasConfig {
+        chunks_dir: dir.path().join("chunks"),
+        ..Default::default()
+    };
+    let store = Arc::new(CasStore::open(config).await.unwrap());
+
+    let file_data = b"This is test audio file content for testing.";
+    let chunk_hash = store.put(file_data).await.unwrap();
+
+    let mut builder = TreeBuilder::new();
+    builder.add_file(&make_file_meta(
+        1,
+        "/Artist/Album/Track.flac",
+        file_data.len() as u64,
+    ));
+    let _tree = Arc::new(RwLock::new(builder.build()));
+
+    let reader = Arc::new(FileReader::new(store.clone()));
+    reader.register_manifest(ChunkManifest {
+        file_id: FileId(1),
+        total_size: file_data.len() as u64,
+        chunks: vec![ChunkRef {
+            hash: chunk_hash,
+            offset: 0,
+            size: file_data.len() as u32,
+        }],
+    });
+
+    let result = reader
+        .read(FileId(1), 0, file_data.len() as u32)
+        .await
+        .unwrap();
+    assert_eq!(&result[..], file_data);
+}
+
+#[tokio::test]
+async fn test_cache_persistence() {
+    let dir = TempDir::new().unwrap();
+    let config = CasConfig {
+        chunks_dir: dir.path().join("chunks"),
+        ..Default::default()
+    };
+
+    let data = b"persistent data";
+    let hash = {
+        let store = CasStore::open(config.clone()).await.unwrap();
+        store.put(data).await.unwrap()
+    };
+
+    let store = CasStore::open(config).await.unwrap();
+    let retrieved = store.get(&hash).await.unwrap();
+    assert_eq!(&retrieved[..], data);
+}
+
+#[tokio::test]
+async fn test_deduplication() {
+    let dir = TempDir::new().unwrap();
+    let config = CasConfig {
+        chunks_dir: dir.path().join("chunks"),
+        ..Default::default()
+    };
+    let store = CasStore::open(config).await.unwrap();
+
+    let data = b"duplicate this content";
+
+    let hash1 = store.put(data).await.unwrap();
+    let size_after_first = store.current_size();
+
+    let hash2 = store.put(data).await.unwrap();
+    let size_after_second = store.current_size();
+
+    assert_eq!(hash1, hash2);
+    assert_eq!(size_after_first, size_after_second);
+}