Add VideoWall feature: server-side preview clip generation and mobile grid view

Backend (Rust/Actix-web):
- Add video_preview_clips table and PreviewDao for tracking preview generation
- Add ffmpeg preview clip generator: 10 equally-spaced 1s segments at 480p with CUDA NVENC auto-detection
- Add PreviewClipGenerator actor with semaphore-limited concurrent processing
- Add GET /video/preview and POST /video/preview/status endpoints
- Extend file watcher to detect and queue previews for new videos
- Use relative paths consistently for DB storage (matching EXIF convention)

Frontend (React Native/Expo):
- Add VideoWall grid view with 2-3 column layout of looping preview clips
- Add VideoWallItem component with ActiveVideoPlayer sub-component for lifecycle management
- Add useVideoWall hook for batch status polling with 5s refresh
- Add navigation button in grid header (visible when videos exist)
- Use TextureView surface type to fix Android z-ordering issues
- Optimize memory: players only mount while visible via FlatList windowSize
- Configure ExoPlayer buffer options and caching for short clips
- Tap to toggle audio focus, long press to open in full viewer

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/video/actors.rs

@@ -1,5 +1,7 @@
+use crate::database::PreviewDao;
 use crate::is_video;
 use crate::otel::global_tracer;
+use crate::video::ffmpeg::generate_preview_clip;
 use actix::prelude::*;
 use futures::TryFutureExt;
 use log::{debug, error, info, trace, warn};
@@ -8,7 +10,7 @@ use opentelemetry::trace::{Span, Status, Tracer};
 use std::io::Result;
 use std::path::{Path, PathBuf};
 use std::process::{Child, Command, ExitStatus, Stdio};
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 use tokio::sync::Semaphore;
 use walkdir::{DirEntry, WalkDir};
 // ffmpeg -i test.mp4 -c:v h264 -flags +cgop -g 30 -hls_time 3 out.m3u8
@@ -484,3 +486,118 @@ impl Handler<GeneratePlaylistMessage> for PlaylistGenerator {
         })
     }
 }
+
+#[derive(Message)]
+#[rtype(result = "()")]
+pub struct GeneratePreviewClipMessage {
+    pub video_path: String,
+}
+
+pub struct PreviewClipGenerator {
+    semaphore: Arc<Semaphore>,
+    preview_clips_dir: String,
+    base_path: String,
+    preview_dao: Arc<Mutex<Box<dyn PreviewDao>>>,
+}
+
+impl PreviewClipGenerator {
+    pub fn new(
+        preview_clips_dir: String,
+        base_path: String,
+        preview_dao: Arc<Mutex<Box<dyn PreviewDao>>>,
+    ) -> Self {
+        PreviewClipGenerator {
+            semaphore: Arc::new(Semaphore::new(2)),
+            preview_clips_dir,
+            base_path,
+            preview_dao,
+        }
+    }
+}
+
+impl Actor for PreviewClipGenerator {
+    type Context = Context<Self>;
+}
+
+impl Handler<GeneratePreviewClipMessage> for PreviewClipGenerator {
+    type Result = ResponseFuture<()>;
+
+    fn handle(
+        &mut self,
+        msg: GeneratePreviewClipMessage,
+        _ctx: &mut Self::Context,
+    ) -> Self::Result {
+        let semaphore = self.semaphore.clone();
+        let preview_clips_dir = self.preview_clips_dir.clone();
+        let base_path = self.base_path.clone();
+        let preview_dao = self.preview_dao.clone();
+        let video_path = msg.video_path;
+
+        Box::pin(async move {
+            let permit = semaphore
+                .acquire_owned()
+                .await
+                .expect("Unable to acquire preview semaphore");
+
+            // Compute relative path (from BASE_PATH) for DB operations, consistent with EXIF convention
+            let relative_path = video_path
+                .strip_prefix(&base_path)
+                .unwrap_or(&video_path)
+                .trim_start_matches(['/', '\\'])
+                .to_string();
+
+            // Update status to processing
+            {
+                let otel_ctx = opentelemetry::Context::current();
+                let mut dao = preview_dao.lock().expect("Unable to lock PreviewDao");
+                let _ = dao.update_status(&otel_ctx, &relative_path, "processing", None, None, None);
+            }
+
+            // Compute output path: join preview_clips_dir with relative path, change ext to .mp4
+            let output_path = PathBuf::from(&preview_clips_dir)
+                .join(&relative_path)
+                .with_extension("mp4");
+            let output_str = output_path.to_string_lossy().to_string();
+
+            let video_path_owned = video_path.clone();
+            let relative_path_owned = relative_path.clone();
+            tokio::spawn(async move {
+                match generate_preview_clip(&video_path_owned, &output_str).await {
+                    Ok((duration, size)) => {
+                        info!(
+                            "Preview clip complete for '{}' ({:.1}s, {} bytes)",
+                            relative_path_owned, duration, size
+                        );
+                        let otel_ctx = opentelemetry::Context::current();
+                        let mut dao = preview_dao.lock().expect("Unable to lock PreviewDao");
+                        let _ = dao.update_status(
+                            &otel_ctx,
+                            &relative_path_owned,
+                            "complete",
+                            Some(duration as f32),
+                            Some(size as i32),
+                            None,
+                        );
+                    }
+                    Err(e) => {
+                        error!(
+                            "Failed to generate preview clip for '{}': {}",
+                            relative_path_owned, e
+                        );
+                        let otel_ctx = opentelemetry::Context::current();
+                        let mut dao = preview_dao.lock().expect("Unable to lock PreviewDao");
+                        let _ = dao.update_status(
+                            &otel_ctx,
+                            &relative_path_owned,
+                            "failed",
+                            None,
+                            None,
+                            Some(&e.to_string()),
+                        );
+                    }
+                }
+                drop(permit);
+            });
+        })
+    }
+}