Complete Clean Architecture migration

Phase 1-7: Full migration from src/app/ to Clean Architecture

BREAKING CHANGES:
- Removed src/app/ (old TEA-style implementation)
- Removed src/constant.rs (constants now local to modules)
- Removed deprecated canvas_to_image_coords functions

NEW STRUCTURE:
- src/ui/           - UI Layer (COSMIC interface)
- src/application/  - Application Layer (DocumentManager, Commands)
- src/domain/       - Domain Layer (Document types, Operations)
- src/infrastructure/ - Infrastructure Layer (Loaders, Cache, System)

FEATURES:
- DocumentManager as Single Source of Truth
- Command Pattern for all operations
- Model caching for render data (performance)
- Sync mechanism between DocumentManager and UI Model
- Wallpaper support (COSMIC, KDE, GNOME, feh)
- Thumbnail cache with disk persistence

IMPROVEMENTS:
- Warnings: 62 → 43 (-31%)
- Deprecated warnings: 2 → 0 (-100%)
- Code removed: src/app/ (~2000 lines), constant.rs, deprecated functions
- Better Locality of Reference (constants local to modules)
- Clean separation of concerns
- No circular dependencies

DOCUMENTATION:
- Updated AGENTS.md (100% migration status)
- Updated README.md (architecture section)
- Updated Workflow.md
- Added Migration-Plan.md with full completion summary

TESTS:
- All 41 tests passing
- Build successful (0 errors, 43 warnings)
- Release build verified

Migration Status: ✅ 100% Complete

src/application/document_manager.rs

@@ -0,0 +1,274 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// src/application/document_manager.rs
+//
+// Document manager: orchestrates document lifecycle and navigation.
+
+use std::path::{Path, PathBuf};
+
+use crate::domain::document::core::content::DocumentContent;
+use crate::domain::document::core::document::{DocResult, Renderable};
+use crate::domain::document::core::metadata::DocumentMeta;
+use crate::infrastructure::filesystem::file_ops;
+use crate::infrastructure::loaders::DocumentLoaderFactory;
+
+/// Central document manager.
+///
+/// Orchestrates document loading, metadata extraction, and folder navigation.
+pub struct DocumentManager {
+    /// Current document (if any).
+    current_document: Option<DocumentContent>,
+    /// Current document path.
+    current_path: Option<PathBuf>,
+    /// Current document metadata.
+    current_metadata: Option<DocumentMeta>,
+    /// Folder entries for navigation.
+    folder_entries: Vec<PathBuf>,
+    /// Current index in folder entries.
+    current_index: Option<usize>,
+    /// Document loader factory.
+    loader: DocumentLoaderFactory,
+}
+
+impl DocumentManager {
+    /// Create a new document manager.
+    #[must_use]
+    pub fn new() -> Self {
+        Self {
+            current_document: None,
+            current_path: None,
+            current_metadata: None,
+            folder_entries: Vec::new(),
+            current_index: None,
+            loader: DocumentLoaderFactory::new(),
+        }
+    }
+
+    /// Open a document from a file path or directory.
+    ///
+    /// If a directory is provided, opens the first supported file found.
+    /// Also scans the parent folder for navigation.
+    pub fn open_document(&mut self, path: &Path) -> DocResult<()> {
+        // Determine the actual file to open
+        let file_path = if path.is_dir() {
+            // Scan directory and find first supported file
+            self.scan_folder(path);
+
+            self.folder_entries
+                .first()
+                .ok_or_else(|| anyhow::anyhow!("No supported files found in directory"))?
+                .clone()
+        } else {
+            path.to_path_buf()
+        };
+
+        // Load the document
+        let document = self.loader.load(&file_path)?;
+
+        // Extract metadata
+        let metadata = self.extract_metadata(&file_path, &document);
+
+        // Scan folder for navigation if not already done
+        if !path.is_dir() {
+            if let Some(parent) = file_path.parent() {
+                self.scan_folder(parent);
+            }
+        }
+
+        // Find current document index
+        self.current_index = self.folder_entries.iter().position(|p| p == &file_path);
+
+        // Generate thumbnails for multi-page documents (PDF)
+        let mut document = document;
+        if document.is_multi_page() {
+            log::info!("Generating thumbnails for multi-page document...");
+            if let Err(e) = document.generate_thumbnails() {
+                log::warn!("Failed to generate thumbnails: {e}");
+            }
+        }
+
+        self.current_document = Some(document);
+        self.current_path = Some(file_path);
+        self.current_metadata = Some(metadata);
+
+        Ok(())
+    }
+
+    /// Get the current document.
+    #[must_use]
+    pub fn current_document(&self) -> Option<&DocumentContent> {
+        self.current_document.as_ref()
+    }
+
+    /// Get a mutable reference to the current document.
+    #[must_use]
+    pub fn current_document_mut(&mut self) -> Option<&mut DocumentContent> {
+        self.current_document.as_mut()
+    }
+
+    /// Get thumbnail handle for a specific page (read-only access).
+    /// Returns None if the thumbnail hasn't been generated yet.
+    #[must_use]
+    pub fn get_thumbnail_handle(&self, page: usize) -> Option<cosmic::widget::image::Handle> {
+        self.current_document.as_ref()?.get_thumbnail_handle(page)
+    }
+
+    /// Get the current document path.
+    #[must_use]
+    pub fn current_path(&self) -> Option<&Path> {
+        self.current_path.as_deref()
+    }
+
+    /// Get the current document metadata.
+    #[must_use]
+    pub fn current_metadata(&self) -> Option<&DocumentMeta> {
+        self.current_metadata.as_ref()
+    }
+
+    /// Get folder entries for navigation.
+    #[must_use]
+    pub fn folder_entries(&self) -> &[PathBuf] {
+        &self.folder_entries
+    }
+
+    /// Get current index in folder.
+    #[must_use]
+    pub fn current_index(&self) -> Option<usize> {
+        self.current_index
+    }
+
+    /// Navigate to the next document in the folder.
+    ///
+    /// Wraps around to the first document when at the end.
+    pub fn next_document(&mut self) -> Option<PathBuf> {
+        if self.folder_entries.is_empty() {
+            return None;
+        }
+
+        let new_index = match self.current_index {
+            Some(idx) => {
+                if idx + 1 < self.folder_entries.len() {
+                    idx + 1
+                } else {
+                    0 // Wrap around to first
+                }
+            }
+            None => 0,
+        };
+
+        let next_path = self.folder_entries.get(new_index)?.clone();
+        if self.open_document(&next_path).is_ok() {
+            Some(next_path)
+        } else {
+            None
+        }
+    }
+
+    /// Navigate to the previous document in the folder.
+    ///
+    /// Wraps around to the last document when at the beginning.
+    pub fn previous_document(&mut self) -> Option<PathBuf> {
+        if self.folder_entries.is_empty() {
+            return None;
+        }
+
+        let new_index = match self.current_index {
+            Some(idx) => {
+                if idx > 0 {
+                    idx - 1
+                } else {
+                    self.folder_entries.len() - 1 // Wrap around to last
+                }
+            }
+            None => self.folder_entries.len().saturating_sub(1),
+        };
+
+        let prev_path = self.folder_entries.get(new_index)?.clone();
+        if self.open_document(&prev_path).is_ok() {
+            Some(prev_path)
+        } else {
+            None
+        }
+    }
+
+    /// Close the current document.
+    #[allow(dead_code)]
+    pub fn close_document(&mut self) {
+        self.current_document = None;
+        self.current_path = None;
+        self.current_metadata = None;
+    }
+
+    /// Scan a folder for supported documents.
+    fn scan_folder(&mut self, folder: &Path) {
+        self.folder_entries = file_ops::collect_supported_files(folder);
+    }
+
+    /// Extract metadata from a document.
+    fn extract_metadata(&self, path: &Path, document: &DocumentContent) -> DocumentMeta {
+        use crate::domain::document::core::metadata::{BasicMeta, DocumentMeta, ExifMeta};
+
+        let info = document.info();
+        let (width, height) = document.dimensions();
+
+        let file_name = path
+            .file_name()
+            .and_then(|n| n.to_str())
+            .unwrap_or("unknown")
+            .to_string();
+
+        let file_path = path.to_string_lossy().to_string();
+
+        let file_size = std::fs::metadata(path).map(|m| m.len()).unwrap_or(0);
+
+        let format = info.format;
+        let color_type = format!("{}", document.kind());
+
+        let basic = BasicMeta {
+            file_name,
+            file_path,
+            format,
+            width,
+            height,
+            file_size,
+            color_type,
+        };
+
+        // Extract EXIF data for raster images (JPEG, TIFF)
+        let exif =
+            if document.kind() == crate::domain::document::core::content::DocumentKind::Raster {
+                file_ops::read_file_bytes(path).and_then(|bytes| ExifMeta::from_bytes(&bytes))
+            } else {
+                None
+            };
+
+        DocumentMeta { basic, exif }
+    }
+
+    /// Check if there is a next document available.
+    #[must_use]
+    #[allow(dead_code)]
+    pub fn has_next(&self) -> bool {
+        if let Some(current) = self.current_index {
+            current + 1 < self.folder_entries.len()
+        } else {
+            false
+        }
+    }
+
+    /// Check if there is a previous document available.
+    #[must_use]
+    #[allow(dead_code)]
+    pub fn has_previous(&self) -> bool {
+        if let Some(current) = self.current_index {
+            current > 0
+        } else {
+            false
+        }
+    }
+}
+
+impl Default for DocumentManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}