feat: 增强类型转换能力和代码重构

核心改进：
1. 新增 normalizeInputValue 函数
   - 统一处理输入值的规范化，支持 R 接口、[]R 切片、reflect.Value
   - 避免重复封装，提升性能和类型安全性

2. 重构 getValueByPath 为独立函数
   - 从 rfx 方法提取为独立函数，提高代码复用性
   - 更好的职责分离，便于维护和测试

3. 显著增强 setValue 方法的类型转换能力
   - 支持切片类型转换：[]any -> []T，自动转换每个元素
   - 支持结构体类型转换：map -> struct 或 struct -> struct，按字段名匹配
   - 保持指针切片的引用语义，避免不必要的对象复制

4. 新增 tryMapField 函数
   - 支持 Map 键名的大小写不敏感访问
   - 首字母大写的键会自动尝试小写版本（如 "Host" -> "host"）

5. 新增 lowercaseFirst 辅助函数
   - 用于首字母小写转换，配合 Map 键名查找

6. 更新测试用例
   - 新增指针切片的使用示例
   - 展示 []any 包含指针元素的场景

7. 文档全面更新
   - 新增"高级类型转换"章节，详细说明切片、结构体、指针切片等转换
   - 更新特性列表，突出增强的类型转换能力和 R 接口集成
   - 补充 Map 大小写不敏感访问的说明

影响范围：
- reflux.go: 使用 normalizeInputValue 统一输入处理
- rfx.go: 重构并增强 setValue、getValueByPath 等核心方法
- util.go: 新增多个辅助函数，代码行数增加 160 行
- rfx_example_test.go: 新增指针切片测试用例

向后兼容：完全兼容现有 API，仅增强内部实现和类型转换能力

README.md

@@ -12,10 +12,12 @@ Reflux 是一个 Go 语言包,提供了统一的接口用于访问和操作嵌
 - 📋 **深度克隆**: Scope 方法和值传递模式创建深度克隆,修改不影响原始数据
 - 🎭 **灵活模式**: 支持指针和值两种传递方式,提供不同的数据操作语义
 - 🔌 **Interface 支持**: 自动解析 `interface{}` 类型到实际类型
-- 🔤 **大小写不敏感**: 支持使用小写字段名访问和修改结构体字段
+- 🔤 **大小写不敏感**: 支持使用小写字段名访问和修改结构体字段(包括 Map 键名)
 - 🔑 **键名提取**: Keys 方法可获取结构体或 Map 的所有键名
 - 📝 **JSON 集成**: Ptr() 方法返回的指针可直接用于 json.Unmarshal(),实现动态 JSON 反序列化
 - 🎯 **类型安全**: 使用反射但保证类型安全
+- 🔥 **增强类型转换**: 支持切片和结构体之间的智能转换(如 []any -> []T, map -> struct)
+- 🌀 **R 接口集成**: 支持直接传入 R 接口或 []R 切片,无缝集成反射值
 - 🚀 **高性能**: 优化的反射操作,低内存开销
 - 📦 **零依赖**: 仅依赖 Go 标准库和 spf13/cast
 
@@ -157,9 +159,14 @@ value := rfx.Get("Meta", "key").String()
 // 获取 Map 值 - 使用点号
 value := rfx.Get("Meta.key").String()
 
-// 大小写不敏感访问 (自动转换为正确的字段名)
+// 大小写不敏感访问 - 结构体字段和 Map 键名
 name := rfx.Get("name").String()  // 等同于 Get("Name")
 city := rfx.Get("address.city").String()  // 等同于 Get("Address.City")
+
+// Map 类型也支持大小写转换
+config := map[string]string{"Host": "localhost"}
+rfx := reflux.New(&config)
+host := rfx.Get("host").String()  // 自动尝试 "Host"
 ```
 
 ### 3. 作用域 (Scope)
@@ -240,12 +247,154 @@ rfx.Set("address.city", "Shanghai")  // 等同于 Set("Address.City", "Shanghai"
 // 自动类型转换
 rfx.Set("Age", int32(35))  // int32 -> int
 
+// 切片类型转换 - 从通用切片转为具体类型
+rfx.Set("Scores", []any{90, 95, 88})  // []any -> []int
+
+// 结构体类型转换 - 从 map 填充到 struct
+addressMap := map[string]any{
+    "City":   "Shanghai",
+    "Street": "Nanjing Road",
+}
+rfx.Set("Address", addressMap)  // map -> Address struct
+
+// 指针切片赋值 - 保持指针引用
+type Item struct {
+    Name string
+}
+item1 := &Item{Name: "apple"}
+item2 := &Item{Name: "banana"}
+rfx.Set("Items", []*Item{item1, item2})  // 保持原指针地址
+
+// 也支持从 []any 包含指针元素
+rfx.Set("Items", []any{item1, item2})  // 复用指针地址
+
+// R 接口和 []R 切片支持
+rfx1 := reflux.New(data1)
+rfx2 := reflux.New(data2)
+rfx.Set("Item", rfx1)           // 直接传入 R 接口
+rfx.Set("Items", []R{rfx1, rfx2})  // 传入 R 切片
+
 // Map 自动初始化
 rfx.Set("NewMap.key", "value")  // 如果 NewMap 是 nil,会自动初始化
 ```
 
 **注意**: 如果设置失败(路径不存在、类型不匹配等),会 panic。
 
+#### 高级类型转换
+
+Reflux 提供了强大的智能类型转换能力,支持多种复杂场景:
+
+**1. 切片类型转换**
+
+支持从通用切片(如 `[]any`)转换为具体类型切片:
+
+```go
+type Person struct {
+    Scores []int
+    Tags   []string
+}
+
+p := Person{}
+rfx := reflux.New(&p)
+
+// []any -> []int
+rfx.Set("Scores", []any{90, 95, 88})
+// p.Scores = []int{90, 95, 88}
+
+// []any -> []string (自动类型转换)
+rfx.Set("Tags", []any{"go", "rust", 123})
+// p.Tags = []string{"go", "rust", "123"}
+```
+
+**2. 结构体类型转换**
+
+支持从 map 或其他结构体填充到目标结构体:
+
+```go
+type Address struct {
+    City   string
+    Street string
+}
+
+type Person struct {
+    Address Address
+}
+
+p := Person{}
+rfx := reflux.New(&p)
+
+// map -> struct
+addressMap := map[string]any{
+    "City":   "Shanghai",
+    "Street": "Nanjing Road",
+}
+rfx.Set("Address", addressMap)
+// p.Address = Address{City: "Shanghai", Street: "Nanjing Road"}
+
+// struct -> struct (按字段名匹配)
+src := Address{City: "Beijing", Street: "Changan"}
+rfx.Set("Address", src)
+```
+
+**3. 指针切片处理**
+
+对于包含指针的切片,Reflux 会保持指针引用:
+
+```go
+type Fruit struct {
+    Name string
+}
+
+type Basket struct {
+    Fruits []*Fruit
+}
+
+basket := Basket{}
+rfx := reflux.New(&basket)
+
+apple := &Fruit{Name: "apple"}
+banana := &Fruit{Name: "banana"}
+
+// 保持指针引用,不创建新对象
+rfx.Set("Fruits", []*Fruit{apple, banana})
+
+// 修改原指针对象,basket.Fruits 中会看到相同变化
+apple.Name = "green apple"
+// basket.Fruits[0].Name == "green apple"
+
+// 也支持从 []any 赋值,复用指针地址
+rfx.Set("Fruits", []any{apple, banana})
+```
+
+**4. R 接口集成**
+
+支持直接传入 R 接口或 []R 切片:
+
+```go
+// 传入单个 R 接口
+data1 := map[string]string{"key": "value"}
+rfx1 := reflux.New(data1)
+rfx.Set("Item", rfx1)  // 自动提取底层值
+
+// 传入 []R 切片
+data2 := map[string]int{"count": 10}
+rfx2 := reflux.New(data2)
+rfx.Set("Items", []R{rfx1, rfx2})  // 自动转换为底层切片
+```
+
+**5. reflect.Value 支持**
+
+可以直接传入 `reflect.Value`,避免重复封装:
+
+```go
+import "reflect"
+
+val := reflect.ValueOf(someData)
+rfx.Set("Field", val)  // 直接使用,不重复包装
+```
+
+这些高级转换特性使得 Reflux 在处理复杂数据结构和动态类型场景时更加灵活和强大。
+
 #### 切片追加 (Append)
 
 `Append` 用于在当前 `R` 对应的切片上追加一个或多个元素,并支持自动类型转换: