chore(lint): address clippy 1.95 findings in existing modules

CI upgraded to Rust 1.95 and flagged ten pre-existing warnings that
older toolchains did not enforce. None relate to the Gemini proxy
integration PR itself but they block CI on the feature branch, so
clean them up here as a separate commit for easy review:

collapsible_match:
- proxy/providers/gemini_schema.rs: `"items" if value.is_object()`
  match guard instead of nested if.
- proxy/providers/transform_responses.rs: fold
  `map_responses_stop_reason`'s `"completed"` / `"incomplete"` arms
  into match guards, relying on the existing `_ => "end_turn"` fall-
  through for non-matching guard conditions (semantics preserved).
- services/session_usage_codex.rs: fold
  `"session_meta" if state.session_id.is_none()` guard, relying on
  the existing `_ => {}` fall-through.

unnecessary_sort_by:
- services/provider/endpoints.rs: `sort_by_key(|ep| Reverse(ep.added_at))`.
- services/skill.rs (backup list): same Reverse idiom on `created_at`.
- services/skill.rs (skill listings x2): `sort_by_key(|s| s.name.to_lowercase())`.

useless_conversion:
- services/skill.rs: drop the explicit `.into_iter()` on `zip`'s argument.

while_let_loop:
- services/webdav_auto_sync.rs: `while let Some(wait_for) = ...`
  instead of `loop { let Some(...) = ... else { break }; ... }`.

All changes are mechanical and preserve behavior. `cargo test --lib`
remains green (868 passed).

src-tauri/src/proxy/providers/gemini_schema.rs

@@ -188,10 +188,8 @@ fn to_gemini_schema(schema: Value) -> Value {
                             result.insert("properties".to_string(), Value::Object(converted));
                         }
                     }
-                    "items" => {
-                        if value.is_object() {
-                            result.insert("items".to_string(), to_gemini_schema(value));
-                        }
+                    "items" if value.is_object() => {
+                        result.insert("items".to_string(), to_gemini_schema(value));
                     }
                     "anyOf" => {
                         if let Some(values) = value.as_array() {

src-tauri/src/proxy/providers/transform_responses.rs

@@ -194,23 +194,14 @@ pub(crate) fn map_responses_stop_reason(
     incomplete_reason: Option<&str>,
 ) -> Option<&'static str> {
     status.map(|s| match s {
-        "completed" => {
-            if has_tool_use {
-                "tool_use"
-            } else {
-                "end_turn"
-            }
-        }
-        "incomplete" => {
+        "completed" if has_tool_use => "tool_use",
+        "incomplete"
             if matches!(
                 incomplete_reason,
                 Some("max_output_tokens") | Some("max_tokens")
-            ) || incomplete_reason.is_none()
-            {
-                "max_tokens"
-            } else {
-                "end_turn"
-            }
+            ) || incomplete_reason.is_none() =>
+        {
+            "max_tokens"
         }
         _ => "end_turn",
     })

src-tauri/src/services/provider/endpoints.rs

@@ -27,7 +27,7 @@ pub fn get_custom_endpoints(
     }
 
     let mut result: Vec<_> = meta.custom_endpoints.values().cloned().collect();
-    result.sort_by(|a, b| b.added_at.cmp(&a.added_at));
+    result.sort_by_key(|ep| std::cmp::Reverse(ep.added_at));
     Ok(result)
 }
 

src-tauri/src/services/session_usage_codex.rs

@@ -297,18 +297,16 @@ fn sync_single_codex_file(db: &Database, file_path: &Path) -> Result<(u32, u32),
         };
 
         match event_type {
-            "session_meta" => {
-                if state.session_id.is_none() {
-                    let payload = value.get("payload");
-                    state.session_id = payload
-                        .and_then(|p| {
-                            p.get("session_id")
-                                .or_else(|| p.get("sessionId"))
-                                .or_else(|| p.get("id"))
-                        })
-                        .and_then(|v| v.as_str())
-                        .map(|s| s.to_string());
-                }
+            "session_meta" if state.session_id.is_none() => {
+                let payload = value.get("payload");
+                state.session_id = payload
+                    .and_then(|p| {
+                        p.get("session_id")
+                            .or_else(|| p.get("sessionId"))
+                            .or_else(|| p.get("id"))
+                    })
+                    .and_then(|v| v.as_str())
+                    .map(|s| s.to_string());
             }
             "turn_context" => {
                 if let Some(payload) = value.get("payload") {

src-tauri/src/services/skill.rs

@@ -1268,7 +1268,7 @@ impl SkillService {
             }
         }
 
-        entries.sort_by(|a, b| b.created_at.cmp(&a.created_at));
+        entries.sort_by_key(|entry| std::cmp::Reverse(entry.created_at));
         Ok(entries)
     }
 
@@ -1772,7 +1772,7 @@ impl SkillService {
         let results: Vec<Result<Vec<DiscoverableSkill>>> =
             futures::future::join_all(fetch_tasks).await;
 
-        for (repo, result) in enabled_repos.into_iter().zip(results.into_iter()) {
+        for (repo, result) in enabled_repos.into_iter().zip(results) {
             match result {
                 Ok(repo_skills) => skills.extend(repo_skills),
                 Err(e) => log::warn!("获取仓库 {}/{} 技能失败: {}", repo.owner, repo.name, e),
@@ -1781,7 +1781,7 @@ impl SkillService {
 
         // 去重并排序
         Self::deduplicate_discoverable_skills(&mut skills);
-        skills.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
+        skills.sort_by_key(|skill| skill.name.to_lowercase());
 
         Ok(skills)
     }
@@ -1848,7 +1848,7 @@ impl SkillService {
             }
         }
 
-        skills.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
+        skills.sort_by_key(|skill| skill.name.to_lowercase());
 
         Ok(skills)
     }

src-tauri/src/services/webdav_auto_sync.rs

@@ -173,10 +173,7 @@ async fn run_worker_loop(
         let started_at = Instant::now();
         let mut merged_count = 1usize;
 
-        loop {
-            let Some(wait_for) = auto_sync_wait_duration(started_at, Instant::now()) else {
-                break;
-            };
+        while let Some(wait_for) = auto_sync_wait_duration(started_at, Instant::now()) {
             let timeout = tokio::time::timeout(wait_for, rx.recv()).await;
 
             match timeout {