Fix critical node position format transformation bug

Fixed "Cannot read properties of undefined (reading 'x')" error when
rendering diagrams in canvas view.

## Problem

.bac4 files store node positions as:
```json
{
  "id": "node-1",
  "type": "system",
  "x": 100,
  "y": 200,
  "data": {...}
}
```

React Flow expects:
```json
{
  "id": "node-1",
  "type": "system",
  "position": { "x": 100, "y": 200 },
  "data": {...}
}
```

Previous code loaded .bac4 files directly without transformation,
causing React Flow to fail when accessing `node.position.x`.

## Solution

Implemented bidirectional transformation in useFileOperations.ts:

**Loading (file → React Flow):**
```typescript
const transformedNodes = validatedNodes.map((node: any) => {
  const { x, y, ...rest } = node;
  return {
    ...rest,
    position: { x: x || 0, y: y || 0 },
  };
});
```

**Saving (React Flow → file):**
```typescript
const savedNodes = inMemorySnapshot.nodes.map((memNode: any) => {
  const { position, ...restNode } = memNode;
  return {
    ...restNode,
    x: position?.x || 0,
    y: position?.y || 0,
  };
});
```

## Impact

- ✅ Diagrams now render correctly in canvas view
- ✅ Node positions preserved when saving
- ✅ Backward compatible with existing .bac4 files
- ✅ Cross-references still preserved correctly

## Testing

Tested with:
- 16 BA Engineering diagrams in BAC4Testv09 vault
- All diagrams load and render correctly
- Manual node repositioning works
- File save/reload preserves positions
- Cross-reference nodes maintain references

## Files Changed

- src/ui/canvas/hooks/useFileOperations.ts
  - Added transformedNodes mapping on load (line 309-313)
  - Added fileFormatNode mapping on save (line 132-137)
  - Preserved cross-reference logic with new format

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: DavidROliverBA

src/ui/canvas/hooks/useFileOperations.ts

@@ -126,19 +126,29 @@ export function useFileOperations(props: UseFileOperationsProps): void {
               // Find corresponding node in disk snapshot (latest version)
               const diskNode = diskCurrentSnapshot?.nodes?.find((n: any) => n.id === memNode.id);
 
+              // Transform from React Flow format back to .bac4 file format
+              // React Flow uses: {position: {x, y}, ...}
+              // .bac4 files need: {x, y, ...}
+              const { position, ...restNode } = memNode as any;
+              const fileFormatNode = {
+                ...restNode,
+                x: position?.x || 0,
+                y: position?.y || 0,
+              };
+
               // If disk version has cross-references, preserve them
               if (diskNode?.data?.isReference && diskNode?.data?.crossReferences) {
                 return {
-                  ...memNode,
+                  ...fileFormatNode,
                   data: {
-                    ...memNode.data,
+                    ...fileFormatNode.data,
                     isReference: diskNode.data.isReference,
                     crossReferences: diskNode.data.crossReferences,
                   },
                 };
               }
 
-              return memNode;
+              return fileFormatNode;
             });
 
             return {
@@ -293,13 +303,24 @@ export function useFileOperations(props: UseFileOperationsProps): void {
             validatedNodes = await validateLinkedFiles(validatedNodes);
           }
 
+          // Transform node format from .bac4 file format to React Flow format
+          // .bac4 files store: {id, type, x, y, width, height, data}
+          // React Flow expects: {id, type, position: {x, y}, width, height, data}
+          const transformedNodes = validatedNodes.map((node: any) => {
+            const { x, y, ...rest } = node;
+            return {
+              ...rest,
+              position: { x: x || 0, y: y || 0 },
+            };
+          });
+
           // Load nodes from current snapshot
           console.log(
             'BAC4: Loading nodes from current snapshot:',
-            validatedNodes.length,
+            transformedNodes.length,
             'nodes'
           );
-          setNodes(validatedNodes);
+          setNodes(transformedNodes);
 
           // Initialize node counter based on existing nodes
           nodeCounterRef.current = initializeNodeCounter(validatedNodes);