patina_internal_collections: Fix bounds checking in Storage::resize()

## Description

Added bounds checking when updating node pointers during resize.
Prevents out-of-bounds access to buffer[idx] when indices from
old storage exceed new buffer size.

Fixes potential panic when resizing to smaller buffers while
preserving node relationships (left/right/parent pointers).

- [x] Impacts functionality?
- [ ] Impacts security?
- [ ] Breaking change?
- [x] Includes tests?
- [ ] Includes documentation?

## How This Was Tested

- Unit tests (`cargo test --package patina_internal_collections`)
- Added test_resize_preserves_valid_pointers to verify fix

## Integration Instructions

- N/A

Author: garybeihl

core/patina_internal_collections/src/node.rs

@@ -218,21 +218,33 @@ where
 
             if let Some(left) = old.left() {
                 let idx = self.idx(left.as_mut_ptr());
-                buffer[i].set_left(Some(&buffer[idx]));
+                if idx < buffer.len() {
+                    buffer[i].set_left(Some(&buffer[idx]));
+                } else {
+                    buffer[i].set_left(None);
+                }
             } else {
                 buffer[i].set_left(None);
             }
 
             if let Some(right) = old.right() {
                 let idx = self.idx(right.as_mut_ptr());
-                buffer[i].set_right(Some(&buffer[idx]));
+                if idx < buffer.len() {
+                    buffer[i].set_right(Some(&buffer[idx]));
+                } else {
+                    buffer[i].set_right(None);
+                }
             } else {
                 buffer[i].set_right(None);
             }
 
             if let Some(parent) = old.parent() {
                 let idx = self.idx(parent.as_mut_ptr());
-                buffer[i].set_parent(Some(&buffer[idx]));
+                if idx < buffer.len() {
+                    buffer[i].set_parent(Some(&buffer[idx]));
+                } else {
+                    buffer[i].set_parent(None);
+                }
             } else {
                 buffer[i].set_parent(None);
             }
@@ -780,4 +792,54 @@ mod tests {
         assert_eq!(node2.right_ptr(), r1.as_mut_ptr());
         assert_eq!(r1.parent_ptr(), node2.as_mut_ptr());
     }
+
+    #[test]
+    fn test_resize_preserves_valid_pointers() {
+        // Test that resize properly handles node relationships during resize.
+        // Before the fix, accessing buffer[idx] could panic if idx >= buffer.len()
+
+        // Create initial storage
+        const INITIAL_SIZE: usize = 10;
+        let mut initial_memory = [0; INITIAL_SIZE * node_size::<usize>()];
+        let mut storage = Storage::<usize>::with_capacity(&mut initial_memory);
+
+        // Add 5 nodes
+        storage.add(100).unwrap(); // idx 0
+        storage.add(200).unwrap(); // idx 1
+        storage.add(300).unwrap(); // idx 2
+        storage.add(400).unwrap(); // idx 3
+        storage.add(500).unwrap(); // idx 4
+
+        // Set up relationships
+        unsafe {
+            let node0 = &mut *storage.get_mut(0).unwrap().as_mut_ptr();
+            let node1 = &mut *storage.get_mut(1).unwrap().as_mut_ptr();
+            let node2 = &mut *storage.get_mut(2).unwrap().as_mut_ptr();
+
+            node0.set_left(Some(node1));
+            node0.set_right(Some(node2));
+            node1.set_parent(Some(node0));
+            node2.set_parent(Some(node0));
+        }
+
+        // Resize to larger buffer
+        const LARGER_SIZE: usize = 20;
+        let mut larger_memory = [0; LARGER_SIZE * node_size::<usize>()];
+        storage.resize(&mut larger_memory);
+
+        // Verify relationships are preserved
+        let node0 = storage.get(0).unwrap();
+        assert!(node0.left().is_some());
+        assert!(node0.right().is_some());
+
+        // Resize back to exact size (5 nodes in use)
+        const EXACT_SIZE: usize = 5;
+        let mut exact_memory = [0; EXACT_SIZE * node_size::<usize>()];
+        storage.resize(&mut exact_memory);
+
+        // Verify relationships are still preserved
+        let node0 = storage.get(0).unwrap();
+        assert!(node0.left().is_some());
+        assert!(node0.right().is_some());
+    }
 }