refactor(rust): reorder imports and improve code formatting

Reorder import statements in multiple files to maintain consistency
and improve readability. Also fix line wrapping issues in several
places to keep lines under 100 characters.

BREAKING CHANGE: None

Author: zTgx

rust/src/index/summary/strategy.rs

@@ -6,8 +6,8 @@
 use async_trait::async_trait;
 
 use crate::document::{DocumentTree, NodeId};
-use crate::llm::{LlmClient, LlmResult};
 use crate::llm::memo::{MemoKey, MemoStore, MemoValue};
+use crate::llm::{LlmClient, LlmResult};
 use crate::utils::fingerprint::Fingerprint;
 
 /// Configuration for summary strategies.

rust/src/llm/executor.rs

@@ -61,8 +61,8 @@ use async_openai::types::chat::{
 use super::config::LlmConfig;
 use super::error::{LlmError, LlmResult};
 use super::fallback::{FallbackChain, FallbackStep};
-use crate::metrics::MetricsHub;
 use super::throttle::ConcurrencyController;
+use crate::metrics::MetricsHub;
 
 /// Unified executor for LLM operations.
 ///

rust/src/llm/memo/store.rs

@@ -426,7 +426,8 @@ impl MemoStore {
         }
 
         // Restore stats
-        self.stats.load_from(data.stats.hits, data.stats.misses, data.stats.tokens_saved);
+        self.stats
+            .load_from(data.stats.hits, data.stats.misses, data.stats.tokens_saved);
 
         info!(
             "Loaded memo store with {} entries from {:?}",

rust/src/llm/pool.rs

@@ -8,8 +8,8 @@ use std::sync::Arc;
 use super::client::LlmClient;
 use super::config::LlmConfig;
 use super::fallback::{FallbackChain, FallbackConfig};
-use crate::metrics::MetricsHub;
 use super::throttle::ConcurrencyController;
+use crate::metrics::MetricsHub;
 
 /// Pool of LLM clients for different purposes.
 ///

rust/src/retrieval/complexity/detector.rs

@@ -60,8 +60,7 @@ impl ComplexityDetector {
         }
 
         let result = if let Some(ref client) = self.llm_client {
-            if let Some(complexity) =
-                crate::retrieval::pilot::detect_with_llm(client, query).await
+            if let Some(complexity) = crate::retrieval::pilot::detect_with_llm(client, query).await
             {
                 complexity
             } else {

rust/src/retrieval/decompose.rs

@@ -47,8 +47,8 @@
 use serde::{Deserialize, Serialize};
 use tracing::{debug, info};
 
-use crate::llm::{LlmClient, LlmExecutor};
 use crate::llm::memo::{MemoKey, MemoOpType, MemoStore, MemoValue};
+use crate::llm::{LlmClient, LlmExecutor};
 use crate::utils::fingerprint::Fingerprint;
 
 /// Sub-query resulting from decomposition.
@@ -269,30 +269,27 @@ impl QueryDecomposer {
         info!("Decomposing complex query: '{}'", query);
 
         // Try LLM-based decomposition if available
-        let result = if self.config.use_llm && (self.llm_client.is_some() || self.llm_executor.is_some()) {
-            match self.llm_decompose(query).await {
-                Ok(result) => result,
-                Err(e) => {
-                    debug!(
-                        "LLM decomposition failed, falling back to rule-based: {}",
-                        e
-                    );
-                    self.rule_based_decompose(query)?
+        let result =
+            if self.config.use_llm && (self.llm_client.is_some() || self.llm_executor.is_some()) {
+                match self.llm_decompose(query).await {
+                    Ok(result) => result,
+                    Err(e) => {
+                        debug!(
+                            "LLM decomposition failed, falling back to rule-based: {}",
+                            e
+                        );
+                        self.rule_based_decompose(query)?
+                    }
                 }
-            }
-        } else {
-            self.rule_based_decompose(query)?
-        };
+            } else {
+                self.rule_based_decompose(query)?
+            };
 
         // Cache the result
         if let Some(ref store) = self.memo_store {
             let cache_key = Self::build_cache_key(query);
             if let Ok(json) = serde_json::to_value(&CachedDecomposition::from_result(&result)) {
-                store.put_with_tokens(
-                    cache_key,
-                    MemoValue::Json(json),
-                    (query.len() / 4) as u64,
-                );
+                store.put_with_tokens(cache_key, MemoValue::Json(json), (query.len() / 4) as u64);
             }
         }
 

rust/src/retrieval/pilot/llm_pilot.rs

@@ -11,8 +11,8 @@ use std::sync::Arc;
 use tracing::{debug, info, warn};
 
 use crate::document::{DocumentTree, NodeId};
-use crate::llm::{LlmClient, LlmExecutor};
 use crate::llm::memo::{MemoKey, MemoStore, MemoValue};
+use crate::llm::{LlmClient, LlmExecutor};
 use crate::utils::fingerprint::Fingerprint;
 
 use super::budget::BudgetController;

rust/src/retrieval/stages/analyze.rs

@@ -164,7 +164,8 @@ impl AnalyzeStage {
         self.complexity_detector = detector;
 
         // Also enable query decomposition
-        let mut decomposer = QueryDecomposer::new(DecompositionConfig::default()).with_llm_client(client);
+        let mut decomposer =
+            QueryDecomposer::new(DecompositionConfig::default()).with_llm_client(client);
         if let Some(ref store) = self.memo_store {
             decomposer = decomposer.with_memo_store(store.clone());
         }

rust/src/retrieval/sufficiency/llm_judge.rs

@@ -171,11 +171,7 @@ Be conservative - only mark as sufficient if you're confident the content answer
         if let Some(ref store) = self.memo_store {
             let cache_key = self.build_cache_key(query, content);
             let tokens = (prompt.len() / 4) as u64;
-            store.put_with_tokens(
-                cache_key,
-                MemoValue::Text(format!("{:?}", result)),
-                tokens,
-            );
+            store.put_with_tokens(cache_key, MemoValue::Text(format!("{:?}", result)), tokens);
         }
 
         result