fix: venue category localization for French language

- Handle case sensitivity in VenueCategory::display_name() by normalizing language to lowercase
- Add debugging for venue category conversion and language parameters
- Fix venue search returning 500 error for no results, now returns empty response
- Categories now properly display as "Magasinage", "Tourisme" etc. in French

Resolves issue where venue categories showed English names instead

src/http/handle_event_location_venue.rs

···
         Ok(response) => {
             debug!("Event location venue search completed: {} results", response.venues.len());
             
-            // Convert to event location format
+            // Convert to event location format with language context
             let event_venues: Vec<EventLocationVenueResult> = response.venues
                 .into_iter()
-                .map(convert_venue_to_event_location_result)
+                .map(|venue| convert_venue_to_event_location_result(venue, Some(&language.to_string())))
                 .collect();
 
             // Prepare template context
···
     ).await {
         Ok(venue_result) => {
             let (is_valid, matched_venue, confidence) = if let Some(venue) = venue_result {
-                let event_venue = convert_venue_to_event_location_result(venue);
+                let event_venue = convert_venue_to_event_location_result(venue, Some(&language.to_string()));
                 (true, Some(event_venue), 0.9) // High confidence for exact matches
             } else {
                 (false, None, 0.0)
···
 }
 
 /// Convert venue search result to event location format
-fn convert_venue_to_event_location_result(venue: VenueSearchResult) -> EventLocationVenueResult {
+fn convert_venue_to_event_location_result(venue: VenueSearchResult, language: Option<&str>) -> EventLocationVenueResult {
     // Extract display name from address or use venue type
     let display_name = match &venue.address {
         crate::atproto::lexicon::community::lexicon::location::Address::Current { name, .. } => {
···
     // Create formatted address
     let formatted_address = Some(format_address_for_display(&venue.address));
 
-    // Extract category from venue details and convert to string
+    // Extract category from venue details and convert to localized string
     let category = venue.details.as_ref()
         .and_then(|details| details.category.as_ref())
-        .map(|cat| cat.display_name(None).to_string());
+        .map(|cat| {
+            let lang_str = language.map(|l| l.to_string());
+            let lang_ref = lang_str.as_deref();
+            tracing::debug!("Venue category: {:?} with language {:?} -> {}", cat, lang_ref, cat.display_name(lang_ref));
+            cat.display_name(lang_ref).to_string()
+        });
 
     // Use venue_type as description if available
     let description = venue.details.as_ref()

src/services/venues/venue_types.rs

···
 
     /// Get localized display name
     pub fn display_name(&self, language: Option<&str>) -> &'static str {
-        match (self, language) {
+        let normalized_language = language.map(|s| s.to_lowercase());
+        let lang_ref = normalized_language.as_deref();
+        
+        match (self, lang_ref) {
             (Self::Restaurant, Some("fr-ca")) => "Restaurant",
             (Self::Restaurant, _) => "Restaurant",
             (Self::Cafe, Some("fr-ca")) => "Café",