Add EXIF search infrastructure (Phase 1 & 2)

Implements foundation for EXIF-based photo search capabilities:

- Add geo.rs module with GPS distance calculations (Haversine + bounding box)
- Extend FilesRequest with EXIF search parameters (camera, GPS, date, media type)
- Add MediaType enum and DateTakenAsc/DateTakenDesc sort options
- Create date_taken index migration for efficient date queries
- Implement ExifDao methods: get_exif_batch, query_by_exif, get_camera_makes
- Add FileWithMetadata struct for date-aware sorting
- Implement date sorting with filename extraction fallback
- Make extract_date_from_filename public for reuse

Next: Integrate EXIF filtering into list_photos() and enhance get_all_tags()

src/database/mod.rs

@@ -191,6 +191,23 @@ pub trait ExifDao: Sync + Send {
     fn update_exif(&mut self, exif_data: InsertImageExif) -> Result<ImageExif, DbError>;
     fn delete_exif(&mut self, file_path: &str) -> Result<(), DbError>;
     fn get_all_with_date_taken(&mut self) -> Result<Vec<(String, i64)>, DbError>;
+
+    /// Batch load EXIF data for multiple file paths (single query)
+    fn get_exif_batch(&mut self, file_paths: &[String]) -> Result<Vec<ImageExif>, DbError>;
+
+    /// Query files by EXIF criteria with optional filters
+    fn query_by_exif(
+        &mut self,
+        camera_make: Option<&str>,
+        camera_model: Option<&str>,
+        lens_model: Option<&str>,
+        gps_bounds: Option<(f64, f64, f64, f64)>, // (min_lat, max_lat, min_lon, max_lon)
+        date_from: Option<i64>,
+        date_to: Option<i64>,
+    ) -> Result<Vec<ImageExif>, DbError>;
+
+    /// Get distinct camera makes with counts
+    fn get_camera_makes(&mut self) -> Result<Vec<(String, i64)>, DbError>;
 }
 
 pub struct SqliteExifDao {
@@ -295,4 +312,90 @@ impl ExifDao for SqliteExifDao {
             })
             .map_err(|_| DbError::new(DbErrorKind::QueryError))
     }
+
+    fn get_exif_batch(&mut self, file_paths: &[String]) -> Result<Vec<ImageExif>, DbError> {
+        use schema::image_exif::dsl::*;
+
+        if file_paths.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        let mut connection = self.connection.lock().expect("Unable to get ExifDao");
+
+        image_exif
+            .filter(file_path.eq_any(file_paths))
+            .load::<ImageExif>(connection.deref_mut())
+            .map_err(|_| DbError::new(DbErrorKind::QueryError))
+    }
+
+    fn query_by_exif(
+        &mut self,
+        camera_make_filter: Option<&str>,
+        camera_model_filter: Option<&str>,
+        lens_model_filter: Option<&str>,
+        gps_bounds: Option<(f64, f64, f64, f64)>,
+        date_from: Option<i64>,
+        date_to: Option<i64>,
+    ) -> Result<Vec<ImageExif>, DbError> {
+        use schema::image_exif::dsl::*;
+
+        let mut connection = self.connection.lock().expect("Unable to get ExifDao");
+        let mut query = image_exif.into_boxed();
+
+        // Camera filters (case-insensitive partial match)
+        if let Some(make) = camera_make_filter {
+            query = query.filter(camera_make.like(format!("%{}%", make)));
+        }
+        if let Some(model) = camera_model_filter {
+            query = query.filter(camera_model.like(format!("%{}%", model)));
+        }
+        if let Some(lens) = lens_model_filter {
+            query = query.filter(lens_model.like(format!("%{}%", lens)));
+        }
+
+        // GPS bounding box
+        if let Some((min_lat, max_lat, min_lon, max_lon)) = gps_bounds {
+            query = query
+                .filter(gps_latitude.between(min_lat, max_lat))
+                .filter(gps_longitude.between(min_lon, max_lon))
+                .filter(gps_latitude.is_not_null())
+                .filter(gps_longitude.is_not_null());
+        }
+
+        // Date range
+        if let Some(from) = date_from {
+            query = query.filter(date_taken.ge(from));
+        }
+        if let Some(to) = date_to {
+            query = query.filter(date_taken.le(to));
+        }
+        if date_from.is_some() || date_to.is_some() {
+            query = query.filter(date_taken.is_not_null());
+        }
+
+        query
+            .load::<ImageExif>(connection.deref_mut())
+            .map_err(|_| DbError::new(DbErrorKind::QueryError))
+    }
+
+    fn get_camera_makes(&mut self) -> Result<Vec<(String, i64)>, DbError> {
+        use diesel::dsl::count;
+        use schema::image_exif::dsl::*;
+
+        let mut connection = self.connection.lock().expect("Unable to get ExifDao");
+
+        image_exif
+            .filter(camera_make.is_not_null())
+            .group_by(camera_make)
+            .select((camera_make, count(id)))
+            .order(count(id).desc())
+            .load::<(Option<String>, i64)>(connection.deref_mut())
+            .map(|records| {
+                records
+                    .into_iter()
+                    .filter_map(|(make, cnt)| make.map(|m| (m, cnt)))
+                    .collect()
+            })
+            .map_err(|_| DbError::new(DbErrorKind::QueryError))
+    }
 }