feat(ast): 添加复合表达式和初始化器解析支持

重构AST表达式枚举，将COMPOUND_LITERAL重命名为COMPOUND，
更新相关结构体定义以支持复合字面量的左右表达式向量表示。

添加lvalue表达式类型用于左值处理，实现完整的初始化器解析功能，
包括大括号初始化列表、成员访问和数组下标的处理逻辑。

更新表达式解析器为基于优先级的递归下降解析，修复变量声明中
初始化表达式的内存泄漏问题。

完善类型限定符和存储类说明符的重复检查机制，增强语法分析的准确性。

libs/parser/tests/test_parser_unit.c

@@ -507,6 +507,90 @@ static void test_parser_unit(void) {
             scc_parse_translation_unit);
     }
 
+    {
+        // 1. 构造参数类型：volatile const char *restrict，并附加 register
+        // 存储类
+        scc_ast_type_t char_type;
+        _scc_ast_type_builtin_init(&char_type, SCC_AST_BUILTIN_TYPE_CHAR);
+        char_type.quals.is_const = true;    // const
+        char_type.quals.is_volatile = true; // volatile
+
+        scc_ast_type_t ptr_to_char;
+        scc_ast_type_pointer_init(&ptr_to_char, &char_type);
+        ptr_to_char.quals.is_restrict = true; // restrict 限定指针
+        ptr_to_char.quals.is_register = true; // register 存储类（作用于参数）
+
+        // 2. 参数声明
+        scc_ast_decl_t param_decl;
+        scc_ast_decl_param_init(&param_decl, &ptr_to_char, "fmt");
+
+        // 3. 返回类型：void *
+        scc_ast_type_t void_type;
+        _scc_ast_type_builtin_init(&void_type, SCC_AST_BUILTIN_TYPE_VOID);
+        scc_ast_type_t ptr_to_void;
+        scc_ast_type_pointer_init(&ptr_to_void, &void_type);
+
+        // 4. 参数列表
+        scc_ast_decl_vec_t params;
+        scc_vec_init(params);
+        scc_vec_push(params, &param_decl);
+
+        // 5. 函数类型（包含 static 和 inline）
+        scc_ast_type_t func_type;
+        scc_ast_type_function_init(&func_type, &ptr_to_void, &params);
+        func_type.quals.is_static = true;
+        func_type.quals.is_inline = true;
+
+        // 6. 函数声明
+        scc_ast_decl_t decl;
+        scc_ast_decl_func_init(&decl, &func_type, "call", NULL);
+
+        // 7. 与解析结果比较
+        SCC_CHECK_AST_WITH_SEMA(&decl.base,
+                                "static inline void *call(volatile register "
+                                "const char *restrict fmt);",
+                                scc_parse_declaration);
+    }
+
+    {
+        scc_ast_expr_t lvalue;
+        scc_ast_expr_lvalue_init(&lvalue, &scc_ast_builtin_type_void);
+
+        scc_ast_expr_t lhs1;
+        scc_ast_expr_member_init(&lhs1, &lvalue, "data");
+        scc_ast_expr_t lhs2;
+        scc_ast_expr_member_init(&lhs2, &lvalue, "size");
+        scc_ast_expr_t lhs3;
+        scc_ast_expr_member_init(&lhs3, &lvalue, "cap");
+
+        scc_ast_expr_t rl0;
+        scc_ast_expr_literal_int_init(&rl0, "0", false);
+        scc_ast_type_t void_ptr;
+        scc_ast_type_pointer_init(&void_ptr, &scc_ast_builtin_type_void);
+        scc_ast_expr_t rhs1;
+        scc_ast_expr_cast_init(&rhs1, &void_ptr, &rl0);
+        scc_ast_expr_t rhs2;
+        scc_ast_expr_literal_int_init(&rhs2, "0", false);
+        scc_ast_expr_t rhs3;
+        scc_ast_expr_literal_int_init(&rhs3, "0", false);
+
+        scc_ast_expr_vec_t lhs_exprs;
+        scc_ast_expr_t *lhs_array[] = {&lhs1, &lhs2, &lhs3};
+        scc_vec_unsafe_from_array(lhs_exprs, lhs_array);
+
+        scc_ast_expr_vec_t rhs_exprs;
+        scc_ast_expr_t *rhs_array[] = {&rhs1, &rhs2, &rhs3};
+        scc_vec_unsafe_from_array(rhs_exprs, rhs_array);
+
+        scc_ast_expr_t expr;
+        scc_ast_expr_compound_init(&expr, &lvalue, &lhs_exprs, &rhs_exprs);
+
+        // FIXME use real records type
+        SCC_CHECK_AST(&expr.base,
+                      "(void){.data = ((void *)0), .size = 0, .cap = 0}",
+                      scc_parse_expression);
+    }
+
     {
         // int (*(*)(void))[5]   (指向函数的指针，该函数返回指向数组的指针)
         // 步骤：
@@ -1018,7 +1102,7 @@ static void test_parser_type(void) {
 
         // _Complex double
         SCC_CHECK_AST((scc_ast_node_t *)&scc_ast_builtin_type_complex_double,
-                      "complex double", _scc_parse_type);
+                      "double complex", _scc_parse_type);
     }
 
     // 2. 带类型限定符的基本类型 (const, volatile)