refactor(backend): complete phase 1 - unified error handling (100%)

Completed the remaining migrations for Phase 1 of backend refactoring plan,
achieving 100% coverage of unified error handling with AppError.

## Changes

### Fully Migrated Modules (Result<T, String> → Result<T, AppError>)

- **claude_plugin.rs** (35 lines changed)
  - Migrated 7 public functions: claude_config_path, ensure_claude_dir_exists,
    read_claude_config, write_claude_config, clear_claude_config,
    claude_config_status, is_claude_config_applied
  - Used AppError::io(), AppError::JsonSerialize, AppError::Config
  - Simplified error handling with helper functions

- **settings.rs** (14 lines changed)
  - Migrated AppSettings::save() and update_settings()
  - Used AppError::io() for file operations
  - Used AppError::JsonSerialize for JSON serialization

- **import_export.rs** (67 lines changed)
  - Migrated 8 functions: create_backup, cleanup_old_backups,
    sync_current_providers_to_live, sync_current_provider_for_app,
    sync_codex_live, sync_claude_live, export_config_to_file,
    import_config_from_file, sync_current_providers_live
  - Used AppError::io(), AppError::json(), AppError::Config
  - Added proper error context with file paths and provider IDs
  - Used AppError::Message for temporary bridge with String-based APIs

### Adapted Interface Calls

- **commands.rs** (30 lines changed)
  - Updated 15 Tauri command handlers to use .map_err(|e| e.to_string())
  - Changed from implicit Into::into to explicit e.to_string()
  - Maintained Result<T, String> interface for Tauri (frontend compatibility)
  - Affected commands: Claude MCP (5), Claude plugin (5), settings (1)

- **mcp.rs** (2 lines changed)
  - Updated claude_mcp::set_mcp_servers_map call
  - Changed from .map_err(Into::into) to .map_err(|e| e.to_string())

## Statistics

- Files changed: 5
- Lines changed: +82/-66 (net +16)
- Compilation: ✅ Success (8.42s, 0 warnings)
- Tests: ✅ 4/4 passed

## Benefits

- **Type Safety**: All infrastructure modules now use strongly-typed AppError
- **Error Context**: File paths and operation types preserved in error chain
- **Code Quality**: Removed ~30 instances of .map_err(|e| format!("...", e))
- **Maintainability**: Consistent error handling pattern across codebase
- **Debugging**: Error source chain preserved with #[source] attribute

## Phase 1 Status: ✅ 100% Complete

All modules migrated:
- ✅ config.rs (Phase 1.1)
- ✅ claude_mcp.rs (Phase 1.1)
- ✅ codex_config.rs (Phase 1.1)
- ✅ app_config.rs (Phase 1.1)
- ✅ store.rs (Phase 1.1)
- ✅ claude_plugin.rs (Phase 1.2)
- ✅ settings.rs (Phase 1.2)
- ✅ import_export.rs (Phase 1.2)
- ✅ commands.rs (interface adaptation complete)
- ✅ mcp.rs (interface adaptation complete)

Ready for Phase 2: Splitting commands.rs by domain.

Co-authored-by: Claude <noreply@anthropic.com>

src-tauri/src/claude_plugin.rs

@@ -1,35 +1,37 @@
 use std::fs;
 use std::path::PathBuf;
 
+use crate::error::AppError;
+
 const CLAUDE_DIR: &str = ".claude";
 const CLAUDE_CONFIG_FILE: &str = "config.json";
 
-fn claude_dir() -> Result<PathBuf, String> {
+fn claude_dir() -> Result<PathBuf, AppError> {
     // 优先使用设置中的覆盖目录
     if let Some(dir) = crate::settings::get_claude_override_dir() {
         return Ok(dir);
     }
-    let home = dirs::home_dir().ok_or_else(|| "无法获取用户主目录".to_string())?;
+    let home = dirs::home_dir()
+        .ok_or_else(|| AppError::Config("无法获取用户主目录".into()))?;
     Ok(home.join(CLAUDE_DIR))
 }
 
-pub fn claude_config_path() -> Result<PathBuf, String> {
+pub fn claude_config_path() -> Result<PathBuf, AppError> {
     Ok(claude_dir()?.join(CLAUDE_CONFIG_FILE))
 }
 
-pub fn ensure_claude_dir_exists() -> Result<PathBuf, String> {
+pub fn ensure_claude_dir_exists() -> Result<PathBuf, AppError> {
     let dir = claude_dir()?;
     if !dir.exists() {
-        fs::create_dir_all(&dir).map_err(|e| format!("创建 Claude 配置目录失败: {}", e))?;
+        fs::create_dir_all(&dir).map_err(|e| AppError::io(&dir, e))?;
     }
     Ok(dir)
 }
 
-pub fn read_claude_config() -> Result<Option<String>, String> {
+pub fn read_claude_config() -> Result<Option<String>, AppError> {
     let path = claude_config_path()?;
     if path.exists() {
-        let content =
-            fs::read_to_string(&path).map_err(|e| format!("读取 Claude 配置失败: {}", e))?;
+        let content = fs::read_to_string(&path).map_err(|e| AppError::io(&path, e))?;
         Ok(Some(content))
     } else {
         Ok(None)
@@ -47,7 +49,7 @@ fn is_managed_config(content: &str) -> bool {
     }
 }
 
-pub fn write_claude_config() -> Result<bool, String> {
+pub fn write_claude_config() -> Result<bool, AppError> {
     // 增量写入：仅设置 primaryApiKey = "any"，保留其它字段
     let path = claude_config_path()?;
     ensure_claude_dir_exists()?;
@@ -78,16 +80,16 @@ pub fn write_claude_config() -> Result<bool, String> {
 
     if changed || !path.exists() {
         let serialized = serde_json::to_string_pretty(&obj)
-            .map_err(|e| format!("序列化 Claude 配置失败: {}", e))?;
+            .map_err(|e| AppError::JsonSerialize { source: e })?;
         fs::write(&path, format!("{}\n", serialized))
-            .map_err(|e| format!("写入 Claude 配置失败: {}", e))?;
+            .map_err(|e| AppError::io(&path, e))?;
         Ok(true)
     } else {
         Ok(false)
     }
 }
 
-pub fn clear_claude_config() -> Result<bool, String> {
+pub fn clear_claude_config() -> Result<bool, AppError> {
     let path = claude_config_path()?;
     if !path.exists() {
         return Ok(false);
@@ -113,18 +115,17 @@ pub fn clear_claude_config() -> Result<bool, String> {
     }
 
     let serialized = serde_json::to_string_pretty(&value)
-        .map_err(|e| format!("序列化 Claude 配置失败: {}", e))?;
-    fs::write(&path, format!("{}\n", serialized))
-        .map_err(|e| format!("写入 Claude 配置失败: {}", e))?;
+        .map_err(|e| AppError::JsonSerialize { source: e })?;
+    fs::write(&path, format!("{}\n", serialized)).map_err(|e| AppError::io(&path, e))?;
     Ok(true)
 }
 
-pub fn claude_config_status() -> Result<(bool, PathBuf), String> {
+pub fn claude_config_status() -> Result<(bool, PathBuf), AppError> {
     let path = claude_config_path()?;
     Ok((path.exists(), path))
 }
 
-pub fn is_claude_config_applied() -> Result<bool, String> {
+pub fn is_claude_config_applied() -> Result<bool, AppError> {
     match read_claude_config()? {
         Some(content) => Ok(is_managed_config(&content)),
         None => Ok(false),