chore(syntax): Test 仓 R1 + R12 迁移

R1：T | t.CPtr -> T*（40 文件 / 1121 处；含多级 **、强转位 (T*)(x)、下标内 list[AST*]）；引号前向引用 'Rect' | t.CPtr 26 处按例外保留，T | t.CPtr | t.State 25 处因 T* 后不能接 | 保持原联合写法。

R12：i = 0 + while i < N: + 尾 i += 1 -> or i in range(N):（10 文件 / 42 处；含 <= -> range(EXPR + 1)、带注解初始化 i: int = 0、尾 i = i + 1）。余 20 处经守卫判定不可安全改写（复合条件 1、尾部非自增 8、体内重绑定/continue 5、while-else 2、循环后仍被读取 2、找不到初始化 2）。

DictTest/App/main.vp

@@ -17,7 +17,7 @@ def main() -> CInt | CExport:
 
     # 分配内存竞技场
     arena: bytes = stdlib.malloc(65536)
-    bd: memhub.MemBuddy | t.CPtr = memhub.MemBuddy(arena, 65536)
+    bd: memhub.MemBuddy* = memhub.MemBuddy(arena, 65536)
 
     # === Test 1: dict set_int / c.Deref 基本操作 ===
     testcheck.section("Test 1: dict set_int / c.Deref 基本操作")
@@ -38,10 +38,10 @@ def main() -> CInt | CExport:
     stdio.printf("p2=%p\n", p2)
     p3: t.CPtr = d["gamma"]
     stdio.printf("p3=%p\n", p3)
-    v1: int = *(int | t.CPtr)(p1)
+    v1: int = *(int*)(p1)
     stdio.printf("v1=%d\n", v1)
-    v2: int = *(int | t.CPtr)(p2)
-    v3: int = *(int | t.CPtr)(p3)
+    v2: int = *(int*)(p2)
+    v3: int = *(int*)(p3)
     stdio.printf("alpha=%d beta=%d gamma=%d\n", v1, v2, v3)
     testcheck.check(v1 == 10, "dict[alpha]==10 OK", "dict[alpha] FAILED")
     testcheck.check(v2 == 20, "dict[beta]==20 OK", "dict[beta] FAILED")
@@ -51,7 +51,7 @@ def main() -> CInt | CExport:
     testcheck.section("Test 2: 更新已有键")
     d.set_int("beta", 99)
     p2b: t.CPtr = d["beta"]
-    v2b: int = *(int | t.CPtr)(p2b)
+    v2b: int = *(int*)(p2b)
     stdio.printf("beta(updated)=%d\n", v2b)
     testcheck.check(v2b == 99, "dict update OK", "dict update FAILED")
     testcheck.check(len(d) == 3, "dict len still 3 OK", "dict len changed FAILED")
@@ -62,7 +62,7 @@ def main() -> CInt | CExport:
     testcheck.check(gv == None, "dict get missing OK (None)", "dict get missing FAILED")
 
     gp: t.CPtr = d.get("alpha", None)
-    ga: int = *(int | t.CPtr)(gp)
+    ga: int = *(int*)(gp)
     stdio.printf("get(alpha)=%d\n", ga)
     testcheck.check(ga == 10, "dict get existing OK", "dict get existing FAILED")
 
@@ -79,7 +79,7 @@ def main() -> CInt | CExport:
     iter_count: int = 0
     for key in d:
         kp: t.CPtr = d[key]
-        val: int = *(int | t.CPtr)(kp)
+        val: int = *(int*)(kp)
         stdio.printf("dict[%s]=%d\n", key, val)
         iter_count += 1
     testcheck.check(iter_count == 3, "dict iter OK (3)", "dict iter FAILED")
@@ -119,12 +119,10 @@ def main() -> CInt | CExport:
     # === Test 8: 扩容测试 ===
     testcheck.section("Test 8: 扩容测试 (>8 个元素)")
     d3: dict = dict(bd)
-    i: int = 0
-    while i < 20:
+    for i in range(20):
         key_buf: str = stdlib.malloc(16)
         stdio.sprintf(key_buf, "key%d", i)
         d3.set_int(key_buf, i * 100)
-        i += 1
     n3: sizet = len(d3)
     stdio.printf("d3 len=%lu (after 20 inserts)\n", n3)
     testcheck.check(n3 == 20, "dict expand OK (20)", "dict expand FAILED")
@@ -133,14 +131,14 @@ def main() -> CInt | CExport:
     k5: str = stdlib.malloc(16)
     stdio.sprintf(k5, "key5")
     p5: t.CPtr = d3[k5]
-    v5: int = *(int | t.CPtr)(p5)
+    v5: int = *(int*)(p5)
     stdio.printf("d3[key5]=%d\n", v5)
     testcheck.check(v5 == 500, "dict expand key5 OK", "dict expand key5 FAILED")
 
     k15: str = stdlib.malloc(16)
     stdio.sprintf(k15, "key15")
     p15: t.CPtr = d3[k15]
-    v15: int = *(int | t.CPtr)(p15)
+    v15: int = *(int*)(p15)
     stdio.printf("d3[key15]=%d\n", v15)
     testcheck.check(v15 == 1500, "dict expand key15 OK", "dict expand key15 FAILED")
 
@@ -165,9 +163,9 @@ def main() -> CInt | CExport:
     xp: t.CPtr = jd2["x"]
     yp: t.CPtr = jd2["y"]
     zp: t.CPtr = jd2["z"]
-    xv: int = *(int | t.CPtr)(xp)
-    yv: int = *(int | t.CPtr)(yp)
-    zv: int = *(int | t.CPtr)(zp)
+    xv: int = *(int*)(xp)
+    yv: int = *(int*)(yp)
+    zv: int = *(int*)(zp)
     stdio.printf("loads: x=%d y=%d z=%d\n", xv, yv, zv)
     testcheck.check(xv == 1, "loads x OK", "loads x FAILED")
     testcheck.check(yv == 2, "loads y OK", "loads y FAILED")
@@ -194,8 +192,8 @@ def main() -> CInt | CExport:
     rt2.loads(pool, rt_str)
     rta_p: t.CPtr = rt2["a"]
     rtb_p: t.CPtr = rt2["b"]
-    rta: int = *(int | t.CPtr)(rta_p)
-    rtb: int = *(int | t.CPtr)(rtb_p)
+    rta: int = *(int*)(rta_p)
+    rtb: int = *(int*)(rtb_p)
     stdio.printf("round-trip: a=%d b=%d\n", rta, rtb)
     testcheck.check(rta == 1, "round-trip a OK", "round-trip a FAILED")
     testcheck.check(rtb == 2, "round-trip b OK", "round-trip b FAILED")
@@ -211,8 +209,8 @@ def main() -> CInt | CExport:
     sub: dict* = outer["sub"]
     sa_p: t.CPtr = sub["a"]
     sb_p: t.CPtr = sub["b"]
-    sa: int = *(int | t.CPtr)(sa_p)
-    sb: int = *(int | t.CPtr)(sb_p)
+    sa: int = *(int*)(sa_p)
+    sb: int = *(int*)(sb_p)
     stdio.printf("nested: sub.a=%d sub.b=%d\n", sa, sb)
     testcheck.check(sa == 1, "nested sub.a OK", "nested sub.a FAILED")
     testcheck.check(sb == 2, "nested sub.b OK", "nested sub.b FAILED")