style: apply rustfmt to backend codebase

- Apply rustfmt to all Rust source files in backend/
- Fix trailing whitespace inconsistencies
- Standardize formatting across handlers, models, and services
- Improve code readability with consistent formatting

These changes are purely stylistic and do not affect functionality.
All CI checks now pass with proper formatting.

backend/src/services/interaction_service.rs

@@ -1,12 +1,11 @@
 //! Interaction Service
-//! 
+//!
 //! Combines ingredient mapping and OpenFDA interaction checking
 //! Provides a unified API for checking drug interactions
 
 use crate::services::{
-    IngredientMapper,
-    OpenFDAService,
-    openfda_service::{DrugInteraction, InteractionSeverity}
+    openfda_service::{DrugInteraction, InteractionSeverity},
+    IngredientMapper, OpenFDAService,
 };
 use mongodb::bson::oid::ObjectId;
 use serde::{Deserialize, Serialize};
@@ -23,56 +22,65 @@ impl InteractionService {
             fda: OpenFDAService::new(),
         }
     }
-    
+
     /// Check interactions between EU medications
     /// Maps EU names to US names, then checks interactions
     pub async fn check_eu_medications(
         &self,
-        eu_medications: &[String]
+        eu_medications: &[String],
     ) -> Result<Vec<DrugInteraction>, Box<dyn std::error::Error>> {
         // Step 1: Map EU names to US names
         let us_medications: Vec<String> = self.mapper.map_many_to_us(eu_medications);
-        
+
         // Step 2: Check interactions using US names
         let interactions = self.fda.check_interactions(&us_medications).await?;
-        
+
         // Step 3: Map back to EU names in response
         let interactions_mapped: Vec<DrugInteraction> = interactions
             .into_iter()
             .map(|mut interaction| {
                 // Map US names back to EU names if they were mapped
                 for (i, eu_name) in eu_medications.iter().enumerate() {
-                    if us_medications.get(i).map(|us| us == &interaction.drug1).unwrap_or(false) {
+                    if us_medications
+                        .get(i)
+                        .map(|us| us == &interaction.drug1)
+                        .unwrap_or(false)
+                    {
                         interaction.drug1 = eu_name.clone();
                     }
-                    if us_medications.get(i).map(|us| us == &interaction.drug2).unwrap_or(false) {
+                    if us_medications
+                        .get(i)
+                        .map(|us| us == &interaction.drug2)
+                        .unwrap_or(false)
+                    {
                         interaction.drug2 = eu_name.clone();
                     }
                 }
                 interaction
             })
             .collect();
-        
+
         Ok(interactions_mapped)
     }
-    
+
     /// Check a single medication against user's current medications
     pub async fn check_new_medication(
         &self,
         new_medication: &str,
-        existing_medications: &[String]
+        existing_medications: &[String],
     ) -> Result<DrugInteractionCheckResult, Box<dyn std::error::Error>> {
         let all_meds = {
             let mut meds = vec![new_medication.to_string()];
             meds.extend_from_slice(existing_medications);
             meds
         };
-        
+
         let interactions = self.check_eu_medications(&all_meds).await?;
-        
-        let has_severe = interactions.iter()
+
+        let has_severe = interactions
+            .iter()
             .any(|i| matches!(i.severity, InteractionSeverity::Severe));
-        
+
         Ok(DrugInteractionCheckResult {
             interactions,
             has_severe,
@@ -97,32 +105,32 @@ pub struct DrugInteractionCheckResult {
 #[cfg(test)]
 mod tests {
     use super::*;
-    
+
     #[tokio::test]
     async fn test_paracetamol_warfarin() {
         let service = InteractionService::new();
-        
+
         // Test EU name mapping + interaction check
         let result = service
             .check_eu_medications(&["paracetamol".to_string(), "warfarin".to_string()])
             .await
             .unwrap();
-        
+
         // Paracetamol maps to acetaminophen, should check against warfarin
         // (Note: actual interaction depends on our known interactions database)
         println!("Interactions found: {:?}", result);
     }
-    
+
     #[tokio::test]
     async fn test_new_medication_check() {
         let service = InteractionService::new();
-        
+
         let existing = vec!["warfarin".to_string()];
         let result = service
             .check_new_medication("aspirin", &existing)
             .await
             .unwrap();
-        
+
         // Warfarin + Aspirin should have severe interaction
         assert_eq!(result.interactions.len(), 1);
         assert!(result.has_severe);