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，仅增强内部实现和类型转换能力

util.go

@@ -1,7 +1,9 @@
 package reflux
 
 import (
+	"fmt"
 	"reflect"
+	"strconv"
 	"strings"
 	"unicode"
 )
@@ -185,6 +187,55 @@ func expandPath(p ...string) []string {
 	return result
 }
 
+// getValueByPath 通过路径获取值的辅助方法
+// 支持两种路径格式:
+// 1. 多个参数: Get("Address", "City")
+// 2. 点号分割: Get("Address.City") 或混合使用 Get("Address.City", "ZipCode")
+func getValueByPath(v reflect.Value, p ...string) reflect.Value {
+	for v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface {
+		if v.IsNil() {
+			return reflect.Value{}
+		}
+		v = v.Elem()
+	}
+
+	// 展开所有路径片段,支持点号分割
+	keys := expandPath(p...)
+
+	for _, key := range keys {
+		if !v.IsValid() {
+			return reflect.Value{}
+		}
+
+		switch v.Kind() {
+		case reflect.Struct:
+			v = tryStructField(v, key)
+		case reflect.Map:
+			v = tryMapField(v, key)
+		case reflect.Slice, reflect.Array:
+			// 尝试将 key 转换为索引
+			idx, err := strconv.Atoi(key)
+			if err == nil && idx >= 0 && idx < v.Len() {
+				v = v.Index(idx)
+			} else {
+				return reflect.Value{}
+			}
+		default:
+			return reflect.Value{}
+		}
+
+		// 解引用指针和接口
+		for v.IsValid() && (v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface) {
+			if v.IsNil() {
+				return reflect.Value{}
+			}
+			v = v.Elem()
+		}
+	}
+
+	return v
+}
+
 // capitalizeFirst 将字符串首字母转换为大写
 // 用于处理 struct 字段名,使其符合 Go 的公开字段命名规范
 func capitalizeFirst(s string) string {
@@ -196,6 +247,16 @@ func capitalizeFirst(s string) string {
 	return string(runes)
 }
 
+// lowercaseFirst 将字符串首字母转换为小写
+func lowercaseFirst(s string) string {
+	if s == "" {
+		return s
+	}
+	runes := []rune(s)
+	runes[0] = unicode.ToLower(runes[0])
+	return string(runes)
+}
+
 // tryStructField 尝试获取 struct 字段,支持小写字段名自动转大写
 // 1. 首先尝试原始字段名
 // 2. 如果失败且首字母是小写,尝试首字母大写的版本
@@ -217,3 +278,102 @@ func tryStructField(v reflect.Value, fieldName string) reflect.Value {
 
 	return reflect.Value{}
 }
+
+// tryMapField 尝试从 map 中获取值,支持 string 键的小写字段名自动转大写
+// 1. 首先使用原始 key 尝试
+// 2. 如果 map 的键类型为 string 且 key 首字母是大写,再尝试首字母小写的版本
+func tryMapField(m reflect.Value, key string) reflect.Value {
+	if !m.IsValid() || m.Kind() != reflect.Map {
+		return reflect.Value{}
+	}
+
+	keyType := m.Type().Key()
+
+	// 构造原始 key
+	var mapKey reflect.Value
+	if keyType.Kind() == reflect.String {
+		mapKey = reflect.ValueOf(key)
+	} else {
+		// 非 string 键,尽量使用原始字符串构造可转换的 key
+		raw := reflect.ValueOf(key)
+		if raw.Type().AssignableTo(keyType) {
+			mapKey = raw
+		} else if raw.Type().ConvertibleTo(keyType) {
+			mapKey = raw.Convert(keyType)
+		} else {
+			return reflect.Value{}
+		}
+	}
+
+	// 尝试原始 key
+	val := m.MapIndex(mapKey)
+	if val.IsValid() {
+		return val
+	}
+
+	// 如果键类型是 string 且首字母大写,尝试首字母小写版本
+	if keyType.Kind() == reflect.String && len(key) > 0 && unicode.IsUpper(rune(key[0])) {
+		lowercased := lowercaseFirst(key)
+		mapKey = reflect.ValueOf(lowercased)
+		val = m.MapIndex(mapKey)
+		if val.IsValid() {
+			return val
+		}
+	}
+
+	return reflect.Value{}
+}
+
+// normalizeInputValue 规范化传入的任意值为 reflect.Value
+// 返回对应的 reflect.Value 以及是否应被视为指针(isPtr)
+func normalizeInputValue(v any) (reflect.Value, bool, error) {
+	var rv reflect.Value
+	var isPtr bool
+
+	if vv, ok := v.(R); ok {
+		isPtr = true
+		rv = vv.Value()
+	} else if vv, ok := v.([]R); ok {
+		// 支持直接传入 []R,自动转换为底层切片
+		var elemType reflect.Type
+		for _, it := range vv {
+			if it == nil {
+				continue
+			}
+			val := it.Value()
+			if val.IsValid() {
+				elemType = val.Type()
+				break
+			}
+		}
+
+		// 如果所有元素都是 nil 或无效,退回到通用处理
+		if elemType == nil {
+			rv = reflect.ValueOf(v)
+		} else {
+			isPtr = true
+			count := len(vv)
+			rv = reflect.MakeSlice(reflect.SliceOf(elemType), count, count)
+			for i, it := range vv {
+				if it == nil {
+					continue
+				}
+				val := it.Value()
+				if !val.IsValid() {
+					continue
+				}
+				if !val.Type().AssignableTo(elemType) {
+					return rv, isPtr, fmt.Errorf("rfx: []R element type mismatch at index %d: got %s, want %s", i, val.Type(), elemType)
+				}
+				rv.Index(i).Set(val)
+			}
+		}
+	} else if vv, ok := v.(reflect.Value); ok {
+		// 支持直接传入 reflect.Value,避免重复封装
+		rv = vv
+	} else {
+		rv = reflect.ValueOf(v)
+	}
+
+	return rv, isPtr || rv.Kind() == reflect.Ptr, nil
+}