refactor(proxy): extract format transform into standalone module

- Create new `proxy/transform/` module with clean architecture:
  - `traits.rs`: FormatTransformer trait definition
  - `format.rs`: ApiFormat enum (Anthropic, OpenAI, Gemini)
  - `registry.rs`: TransformerRegistry with global instance
  - `config.rs`: TransformConfig from Provider settings
  - `anthropic_openai/`: Bidirectional Anthropic ↔ OpenAI converters

- Move streaming transform from providers/ to transform/
- Remove legacy transform code from providers/adapter.rs and claude.rs
- Update handlers.rs to use new transform module

This refactor improves maintainability and makes it easier to add
new format converters in the future.

src-tauri/src/proxy/transform/registry.rs

@@ -0,0 +1,95 @@
+//! 转换器注册表
+//!
+//! 管理和获取格式转换器
+
+use super::{format::ApiFormat, traits::FormatTransformer};
+use std::collections::HashMap;
+use std::sync::{Arc, LazyLock};
+
+/// 转换器注册表
+pub struct TransformerRegistry {
+    transformers: HashMap<(ApiFormat, ApiFormat), Arc<dyn FormatTransformer>>,
+}
+
+impl TransformerRegistry {
+    /// 创建新的注册表
+    pub fn new() -> Self {
+        let mut registry = Self {
+            transformers: HashMap::new(),
+        };
+        registry.register_defaults();
+        registry
+    }
+
+    /// 注册默认转换器
+    fn register_defaults(&mut self) {
+        use super::anthropic_openai::{AnthropicToOpenAITransformer, OpenAIToAnthropicTransformer};
+
+        // Anthropic → OpenAI
+        self.register(Arc::new(AnthropicToOpenAITransformer::new()));
+
+        // OpenAI → Anthropic
+        self.register(Arc::new(OpenAIToAnthropicTransformer::new()));
+    }
+
+    /// 注册转换器
+    pub fn register(&mut self, transformer: Arc<dyn FormatTransformer>) {
+        let key = (transformer.source_format(), transformer.target_format());
+        self.transformers.insert(key, transformer);
+    }
+
+    /// 获取转换器
+    pub fn get(&self, source: ApiFormat, target: ApiFormat) -> Option<Arc<dyn FormatTransformer>> {
+        self.transformers.get(&(source, target)).cloned()
+    }
+
+    /// 检查是否支持指定的转换
+    #[cfg(test)]
+    pub fn supports(&self, source: ApiFormat, target: ApiFormat) -> bool {
+        self.transformers.contains_key(&(source, target))
+    }
+}
+
+impl Default for TransformerRegistry {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// 全局转换器注册表
+pub static TRANSFORMER_REGISTRY: LazyLock<TransformerRegistry> =
+    LazyLock::new(TransformerRegistry::new);
+
+/// 获取转换器的便捷函数
+pub fn get_transformer(source: ApiFormat, target: ApiFormat) -> Option<Arc<dyn FormatTransformer>> {
+    TRANSFORMER_REGISTRY.get(source, target)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_registry_has_default_transformers() {
+        let registry = TransformerRegistry::new();
+
+        // Anthropic → OpenAI
+        assert!(registry.supports(ApiFormat::Anthropic, ApiFormat::OpenAI));
+
+        // OpenAI → Anthropic
+        assert!(registry.supports(ApiFormat::OpenAI, ApiFormat::Anthropic));
+
+        // 不支持的转换
+        assert!(!registry.supports(ApiFormat::Gemini, ApiFormat::OpenAI));
+    }
+
+    #[test]
+    fn test_get_transformer() {
+        let transformer = get_transformer(ApiFormat::Anthropic, ApiFormat::OpenAI);
+        assert!(transformer.is_some());
+
+        let t = transformer.unwrap();
+        assert_eq!(t.source_format(), ApiFormat::Anthropic);
+        assert_eq!(t.target_format(), ApiFormat::OpenAI);
+    }
+}