docs: Inject Mermaid Architecture Diagrams into release notes (#9575)

Author: tobiu

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

@@ -35,12 +35,60 @@ We engineered a completely new hierarchical data foundation that fully supports
 *   **Structural Integrity:** Complex operations like `updateKey` have been overridden to automatically migrate descendant `parentId` references, ensuring the "split-brain" State (where lookup maps get out of sync with record data) is impossible. Full CRUD support is built-in.
 *   **Async Subtree Loading:** For massive datasets that cannot be sent to the client at once, the `TreeStore` supports asynchronous, on-demand loading of child nodes when a user expands a parent branch. We also implemented explicit Error States and dedicated events to handle network failures gracefully within the UI.
 
+```mermaid
+graph TD
+    subgraph "Structural Layer (Deep Maps)"
+    Root((Root)) --> A(Node A <br/> Expanded)
+    Root --> B(Node B <br/> Collapsed)
+    A --> A1(Node A.1)
+    A --> A2(Node A.2)
+    B --> B1(Node B.1)
+    
+    classDef collapsed stroke-dasharray: 5 5;
+    classDef expanded stroke-width:3px;
+    
+    class A expanded;
+    class B collapsed;
+    end
+
+    subgraph "Projection Layer (Flat Array)"
+    F1[Index 0: Node A]
+    F2[Index 1: Node A.1]
+    F3[Index 2: Node A.2]
+    F4[Index 3: Node B]
+    
+    F1 -.-> F2
+    F2 -.-> F3
+    F3 -.-> F4
+    end
+    
+    A -.-> F1
+    A1 -.-> F2
+    A2 -.-> F3
+    B -.-> F4
+```
+
 ### 2. The Data Pipeline Modernization
 To feed the newly minted `TreeStore`, we completely overhauled the Data Worker's ingestion pipeline.
 *   **The Parser-Normalizer Split:** Previously, data came through a single pipeline. We refactored this into a strict, modular flow: `Connection -> Parser -> Normalizer`. The new `Neo.data.normalizer.Base` (and its hierarchical sibling, `Tree`) acts as the final transformation layer, normalizing complex nested payloads from external APIs before handing pure JSON to the App Worker.
 *   **Push-Based WebSocket IPC & RPC:** We integrated persistent WebSocket connections and RPC APIs directly into the `Connection` architecture, enabling real-time streaming of hierarchical mutations from the server directly to the VDOM without polling.
 *   **Dynamic Module Loading:** `Neo.worker.Data` can now dynamically request and instantiate parser/normalizer modules at runtime, deeply minimizing the initial Data Worker bundle size.
 
+```mermaid
+sequenceDiagram
+    participant App as App Worker (Store)
+    participant Pipe as Pipeline
+    participant Data as Data Worker
+    participant Net as Connection Layer
+
+    App->>Pipe: load()
+    Pipe->>Data: Offload Execution (workerExecution: 'data')
+    Data->>Net: Fetch or WebSocket Stream
+    Net-->>Data: Raw Bytes / JSON
+    Data->>Data: Parse & Normalize
+    Data-->>App: Fast IPC Transfer (Records)
+```
+
 ### 3. `Neo.grid.column.Tree` & The Big Data Demo
 The visual counterpart to the `TreeStore` is the new `TreeGrid` column component. 
 *   **O(1) Rendering Hierarchy:** It utilizes semantic indentation (`padding-left` derived from node depth) and interactive expand/collapse toggles natively rendered inside the pooled Grid Cells.