refactor: migrate monolithic crate to Cargo Workspace with Clean Architecture

Transform the single binary crate into a 9-crate workspace monorepo:

- Root Cargo.toml as [workspace] manager with resolver = "2"
- zesdex-entities: Domain entity types (session, settings, store, message, etc.)
- zesdex-utils: Pure utility functions (error, logger, pagination, slug, clipboard)
- zesdex-dto: Data Transfer Objects for LLM provider API communication
- zesdex-ipc: Unix-socket IPC layer (client/server/framing/protocol)
- zesdex-iam: Identity & Access Management (Clean Architecture: domain/application/infrastructure)
- zesdex-cms: Content Management (Clean Architecture: domain/application/infrastructure)
- zesdex-middleware: HTTP middleware (Auth, CORS, Rate Limiting)
- zesdex-libs: Composition root (AppContext, DB init, JWT, Argon2)
- zesdex-backend: Main binary entry point + seed/migrate binaries
- DevOps: Dockerfile, docker-compose, Nix (flake/shell/default), CI/CD updates
- Remove dead root src/ and src-misc/ directories

All crate re-exports maintain backward compatibility with original
crate::model::*, crate::dto::*, crate::ipc::* module paths.
Feature crates enforce strict layer separation: domain -> application
-> infrastructure with generic trait-based dependency injection.

crates/zesdex-cms/src/application/memory_service.rs

@@ -0,0 +1,53 @@
+//! Memory use-case implementations.
+//!
+//! `MemoryServiceImpl` is generic over `R: MemoryRepository`, delegating
+//! all persistence to that adapter.
+
+#![allow(
+    clippy::cast_possible_truncation,
+    clippy::cast_sign_loss,
+    clippy::cast_precision_loss,
+    clippy::cast_possible_wrap
+)]
+
+use anyhow::{Context, Result};
+
+use crate::domain::memory::Memory;
+use crate::domain::repository::MemoryRepository;
+use crate::domain::service::MemoryService;
+
+/// Generic memory service backed by an injected repository.
+pub struct MemoryServiceImpl<R> {
+    pub repo: R,
+    pub memory_dir: std::path::PathBuf,
+}
+
+impl<R: MemoryRepository> MemoryServiceImpl<R> {
+    /// Create a new service with the given repository and memory directory.
+    pub fn new(repo: R, memory_dir: impl Into<std::path::PathBuf>) -> Self {
+        Self {
+            repo,
+            memory_dir: memory_dir.into(),
+        }
+    }
+}
+
+impl<R: MemoryRepository> MemoryService for MemoryServiceImpl<R> {
+    fn list_memories(&self) -> Result<Vec<String>> {
+        self.repo
+            .list(&self.memory_dir)
+            .context("failed to list memories")
+    }
+
+    fn save_memory(&self, memory: &Memory) -> Result<()> {
+        self.repo
+            .save(&self.memory_dir, memory)
+            .with_context(|| format!("failed to save memory '{}'", memory.name))
+    }
+
+    fn delete_memory(&self, name: &str) -> Result<()> {
+        self.repo
+            .delete(&self.memory_dir, name)
+            .with_context(|| format!("failed to delete memory '{name}'"))
+    }
+}