Rewrite ch04 around 2D tensor contraction + cross-chapter content moves

- Ch04: New opening from general 2D tensor contraction concept, GPU
  tensor cores as one example, Croktile's abstract 4-step MMA syntax.
  Added comprehensive MMA variants section (layout, sparse, scale,
  load/swizzle, store/transpose, commit). Renamed "lifecycle" to
  "syntax". Three new Manim figures (tensor contraction, register
  loading, MMA syntax flow), SM86/SM90 renumbered to fig4.
- Ch05: Moved parallel.async/stream s section from ch07 (host launch
  control fits better with control flow chapter).
- Ch06: Added note about swap example's simplified kernel style.
- Ch07: Removed parallel.async aside, added ch04 back-reference in
  swizzle matching rule.
- All changes translated to ZH with consistent terminology.

Made-with: Cursor

Author: SyntaxArchmage

docs/assets/images/ch04/fig1_tensor_contraction_dark.png

@@ -0,0 +1,92 @@
+"""
+Figure 1: 2D tensor contraction as a general concept.
+A[M,K] × B[K,N] → C[M,N] at tile level, with multiple hardware backends.
+"""
+import os, sys
+sys.path.insert(0, os.path.dirname(__file__))
+from manim import *
+from theme import parse_theme
+
+C, THEME = parse_theme()
+
+
+class TensorContraction(Scene):
+    def construct(self):
+        self.camera.background_color = C["bg"]
+
+        title = Text(
+            "2D Tensor Contraction: C += A × B",
+            font_size=22, color=C["fg"], font="Monospace",
+        )
+        title.to_edge(UP, buff=0.3)
+        self.add(title)
+
+        def make_tile(label, w, h, color, pos):
+            r = Rectangle(width=w, height=h, fill_color=color,
+                          fill_opacity=0.2, stroke_color=color, stroke_width=2)
+            t = Text(label, font_size=14, color=color, font="Monospace")
+            g = VGroup(r, t)
+            t.move_to(r.get_center())
+            g.move_to(pos)
+            return g
+
+        y_top = 0.8
+        a = make_tile("A [M, K]", 1.4, 1.8, C["lhs_c"], LEFT * 3.5 + UP * y_top)
+        b = make_tile("B [K, N]", 1.8, 1.4, C["rhs_c"], LEFT * 0.3 + UP * y_top)
+        c_tile = make_tile("C [M, N]", 1.8, 1.8, C["out_c"], RIGHT * 3.0 + UP * y_top)
+
+        times = Text("×", font_size=28, color=C["fg"], font="Monospace")
+        times.move_to((a.get_right() + b.get_left()) / 2)
+        arrow = Arrow(b.get_right() + RIGHT * 0.15, c_tile.get_left() + LEFT * 0.15,
+                      buff=0, stroke_width=2.5, color=C["arrow_c"],
+                      max_tip_length_to_length_ratio=0.15)
+        eq_label = Text("+=", font_size=16, color=C["fg2"], font="Monospace")
+        eq_label.next_to(arrow, UP, buff=0.08)
+
+        self.add(a, b, c_tile, times, arrow, eq_label)
+
+        dim_a = Text("M rows, K cols", font_size=10, color=C["dim"], font="Monospace")
+        dim_a.next_to(a, DOWN, buff=0.12)
+        dim_b = Text("K rows, N cols", font_size=10, color=C["dim"], font="Monospace")
+        dim_b.next_to(b, DOWN, buff=0.12)
+        dim_c = Text("M rows, N cols", font_size=10, color=C["dim"], font="Monospace")
+        dim_c.next_to(c_tile, DOWN, buff=0.12)
+        self.add(dim_a, dim_b, dim_c)
+
+        sub_title = Text(
+            "Same operation, different hardware implementations",
+            font_size=14, color=C["fg3"], font="Monospace",
+        )
+        sub_title.move_to(DOWN * 0.8)
+        self.add(sub_title)
+
+        backends = [
+            ("GPU Tensor Core", "16×16×16 FP16", C["green"]),
+            ("TPU MXU", "128×128 systolic", C["blue"]),
+            ("Intel AMX", "16×64 tiles", C["orange"]),
+            ("Custom DSA", "vendor-specific", C["purple"]),
+        ]
+
+        x_start = -4.5
+        x_step = 3.0
+        y_hw = -2.0
+
+        for i, (name, detail, color) in enumerate(backends):
+            x = x_start + i * x_step
+            box = RoundedRectangle(
+                corner_radius=0.1, width=2.6, height=1.1,
+                fill_color=color, fill_opacity=0.12,
+                stroke_color=color, stroke_width=1.5,
+            )
+            box.move_to([x, y_hw, 0])
+            n = Text(name, font_size=12, color=color, font="Monospace")
+            d = Text(detail, font_size=10, color=C["dim"], font="Monospace")
+            VGroup(n, d).arrange(DOWN, buff=0.08).move_to(box)
+            self.add(box, n, d)
+
+        foot = Text(
+            "Croktile's mma syntax targets the abstract operation, not a specific chip.",
+            font_size=11, color=C["fg3"], font="Monospace",
+        )
+        foot.to_edge(DOWN, buff=0.3)
+        self.add(foot)

docs/assets/images/ch04/fig1_tensor_contraction_light.png

@@ -0,0 +1,82 @@
+"""
+Figure 2: GPU tensor core register layout — fragmented lane ownership.
+Threads in a warp own scattered pieces of the tile; Croktile hides this.
+"""
+import os, sys
+sys.path.insert(0, os.path.dirname(__file__))
+from manim import *
+from theme import parse_theme
+
+C, THEME = parse_theme()
+
+
+class RegisterLoading(Scene):
+    def construct(self):
+        self.camera.background_color = C["bg"]
+
+        title = Text(
+            "Tensor Core Register Layout (simplified)",
+            font_size=20, color=C["fg"], font="Monospace",
+        )
+        title.to_edge(UP, buff=0.3)
+        self.add(title)
+
+        sub = Text(
+            "Each thread in a warp owns scattered register fragments of the tile",
+            font_size=12, color=C["fg3"], font="Monospace",
+        )
+        sub.next_to(title, DOWN, buff=0.15)
+        self.add(sub)
+
+        cell = 0.38
+        rows, cols = 8, 8
+        colors_per_thread = [
+            C["blue"], C["orange"], C["green"], C["purple"],
+            C["red"], C["teal"], C["yellow"], C["pink"],
+        ]
+        ownership = [
+            [0,0,1,1,2,2,3,3],
+            [0,0,1,1,2,2,3,3],
+            [4,4,5,5,6,6,7,7],
+            [4,4,5,5,6,6,7,7],
+            [0,0,1,1,2,2,3,3],
+            [0,0,1,1,2,2,3,3],
+            [4,4,5,5,6,6,7,7],
+            [4,4,5,5,6,6,7,7],
+        ]
+
+        grid_center = LEFT * 2.0 + DOWN * 0.6
+        grid = VGroup()
+        for r in range(rows):
+            for c_idx in range(cols):
+                sq = Square(side_length=cell,
+                            fill_color=colors_per_thread[ownership[r][c_idx]],
+                            fill_opacity=0.3,
+                            stroke_color=colors_per_thread[ownership[r][c_idx]],
+                            stroke_width=1.2)
+                sq.move_to(grid_center + RIGHT * (c_idx - cols/2 + 0.5) * cell
+                           + DOWN * (r - rows/2 + 0.5) * cell)
+                grid.add(sq)
+        self.add(grid)
+
+        tile_label = Text("8×8 MMA tile", font_size=12, color=C["fg2"], font="Monospace")
+        tile_label.next_to(grid, DOWN, buff=0.15)
+        self.add(tile_label)
+
+        legend_title = Text("Thread ownership:", font_size=12, color=C["fg"], font="Monospace")
+        legend_title.move_to(RIGHT * 2.8 + UP * 0.3)
+        self.add(legend_title)
+        for i in range(8):
+            sq = Square(side_length=0.2,
+                        fill_color=colors_per_thread[i], fill_opacity=0.4,
+                        stroke_color=colors_per_thread[i], stroke_width=1)
+            label = Text(f"T{i*4}–T{i*4+3}", font_size=9, color=C["fg2"], font="Monospace")
+            row = VGroup(sq, label).arrange(RIGHT, buff=0.1)
+            row.move_to(RIGHT * 2.8 + DOWN * (0.0 + i * 0.28))
+            self.add(row)
+
+        brace_l = Text("Croktile:", font_size=14, color=C["green"], font="Monospace")
+        brace_r = Text("mma.load / mma.store hide this", font_size=12, color=C["fg2"], font="Monospace")
+        note = VGroup(brace_l, brace_r).arrange(RIGHT, buff=0.15)
+        note.to_edge(DOWN, buff=0.3)
+        self.add(note)