docs(release-notes): Enhance delta log proof with component column granularity (#9341)

Author: tobiu

resources/content/release-notes/v12.0.0.md

@@ -155,8 +155,59 @@ flowchart TD
    * **Resilient Lifecycle:** Component columns (like our Living Sparklines) are now standard children of the `Row` component. Because the row itself is never destroyed, the framework's standard lifecycle manages cell components automatically, permanently eliminating the dreaded "Zombie Canvas" bugs.
 
 2. **The "Fixed-DOM-Order" Strategy (Main Thread):** 
-   * We upgraded `Neo.grid.Body` to enforce strict **Row Pooling**. As you scroll, rows leaving the top of the viewport are recycled in place via CSS `translate3d`.
-   * *The Flex:* When you scroll the 50,000-record DevIndex grid, there are **ZERO structural DOM mutations** (`insertBefore`, `removeChild`, `moveNode`). There can be 600 deltas in a single tick, but they are exclusively fast CSS transforms and `textContent` updates. The DOM order never changes, effectively eliminating layout recalculations.
+   * We upgraded `Neo.grid.Body` to enforce strict **Row Pooling**. As you scroll, rows leaving the top of the viewport are recycled in place via hardware-accelerated CSS `translate3d`.
+   * *The Flex (Empirical Proof):* During maximum-velocity vertical scrolling stress tests on the 50k-record DevIndex, we analyzed the exact composition of the VDOM delta payloads crossing the worker bridge.
+
+```mermaid
+graph TD
+    subgraph Mounted Row Range (DOM Pool)
+        TopBoundary[--- Top of Viewport ---]
+        R1[DOM Row 1: translate3d(0, 0px, 0)]
+        R2[DOM Row 2: translate3d(0, 50px, 0)]
+        R3[DOM Row 3: translate3d(0, 100px, 0)]
+        BottomBoundary[--- Bottom of Viewport ---]
+    end
+
+    Scroll[User Scrolls Down] -->|Moves DOM out of bounds| R1
+    R1 -.->|Teleported to Bottom via GPU| R3
+    
+    style R1 stroke:#f66,stroke-width:2px,stroke-dasharray: 5 5
+```
+
+   * A peak scrolling frame generated **784 deltas**. The payload contained exactly:
+     *   **0 `insertNode` commands.**
+     *   **0 `removeNode` commands.**
+     *   **784 `updateNode` commands.**
+   * This is the definition of a perfectly functioning **DOM Pool**. 
+
+```javascript readonly
+// Empirical Delta Log (The "Zero-Mutation" Proof)
+// Notice the complete absence of HTML string replacements or structural changes.
+[
+  // 1. The Container moves via GPU
+  {
+      "id": "neo-grid-body-1__row-1",
+      "attributes": { "aria-rowindex": "87", "data-record-id": "neo-record-50839", "data-row-id": 85 },
+      "style": { "transform": "translate3d(0px, 4250px, 0px)" }
+  },
+  // 2. A simple text cell updates
+  { 
+      "id": "neo-grid-body-1__row-1__cell-0", 
+      "innerHTML": "86", 
+      "attributes": { "data-record-id": "..." } 
+  },
+  // ...
+  // 3. Ultra-granular deltas INSIDE a Component-Based Column (e.g. the 'Impact' Heuristics column)
+  { 
+      "id": "neo-vnode-353", 
+      "textContent": "🏛️", 
+      "cls": { "add": ["pillar"], "remove": ["bolt"] }, 
+      "attributes": { "title": "Consistency: Community Pillar (>10y)" } 
+  }
+]
+```
+   * We intentionally trade cheap JavaScript cycles (calculating and serializing 800 JSON objects takes **< 3ms**) to completely eliminate Native DOM Layout Thrashing. Even deep inside complex, nested component columns (like the DevIndex "Impact" badges), the framework resolves changes down to microscopic CSS class toggles (`add`/`remove`) and `textContent` updates. 
+   * By using `translate3d` specifically, we force the browser to hand the positioning off to the GPU. Because the strict "mounted row range" limits the total number of DOM nodes, we achieve **Compositor Heaven**: we leverage GPU hardware acceleration without triggering a "layer explosion" that would overwhelm video memory. The browser never recalculates the layout tree because the DOM structure never changes.
 
 3. **"Full Pool Rendering" for Cells (O(1) Horizontal Scroll):**
    * We extended the zero-mutation philosophy to horizontal scrolling. Each row implements a "Full Pool Rendering" strategy, generating a fixed-size array of cell nodes based on the `gridBody.cellPoolSize`.