Add test for deep nested hierarchy preservation in undo/redo

Tests that when a grandparent folder with nested children (grandparent→
parent→5 children) is deleted and undone, the entire hierarchy is correctly
restored with all children nested under their parent (not appearing at root).

This validates the fix for the issue where children would incorrectly appear
at root level after undo because:
1. Items were restored in wrong order (children before parents)
2. Grandchildren's parentID references weren't updated when children got new IDs
3. skipRestore check used modified state instead of original state

The test creates a 3-level hierarchy, deletes the root, undos, and verifies
all children are properly nested (not at root level).

Adds 6 tests (one per item type) to Category 9 (State Consistency)

Author: vadi2

test/dlgTriggerEditorUndoRedoTest.cpp

@@ -1458,7 +1458,7 @@ void runUndoRedoTestSuite(dlgTriggerEditor* editor)
     }
 
     // ====================================================================================
-    // CATEGORY 9: State Consistency Tests (18 tests)
+    // CATEGORY 9: State Consistency Tests (24 tests)
     // ====================================================================================
     qDebug() << "\n=== CATEGORY 9: State Consistency Tests ===";
 
@@ -1525,6 +1525,73 @@ void runUndoRedoTestSuite(dlgTriggerEditor* editor)
             }
         }
 
+        // Test: Deep nested hierarchy preserved after undo (grandparent→parent→children)
+        {
+            // Create a 3-level nested structure with multiple children at level 3
+            itemType.addFolder(); // Grandparent
+            QTreeWidgetItem* grandparent = itemType.baseItem->child(0);
+
+            if (grandparent) {
+                itemType.treeWidget->setCurrentItem(grandparent);
+                itemType.addFolder(); // Parent
+                QTreeWidgetItem* parent = grandparent->child(0);
+
+                if (parent) {
+                    // Add 5 children to the parent
+                    itemType.treeWidget->setCurrentItem(parent);
+                    for (int i = 0; i < 5; i++) {
+                        itemType.addItem();
+                    }
+
+                    int childrenCount = parent->childCount();
+
+                    // Delete the grandparent (should delete entire tree)
+                    itemType.treeWidget->setCurrentItem(grandparent);
+                    int baseCountBefore = itemType.baseItem->childCount();
+                    editor->slot_deleteItemOrGroup();
+
+                    if (itemType.baseItem->childCount() < baseCountBefore) {
+                        // Undo to restore the entire hierarchy
+                        editor->mpUndoStack->undo();
+
+                        // Verify hierarchy is fully restored
+                        QTreeWidgetItem* restoredGP = itemType.baseItem->child(0);
+                        bool hierarchyPreserved = false;
+
+                        if (restoredGP && restoredGP->childCount() == 1) {
+                            QTreeWidgetItem* restoredP = restoredGP->child(0);
+                            if (restoredP && restoredP->childCount() == childrenCount) {
+                                // Verify all children are under parent (not at root)
+                                bool allChildrenNested = true;
+                                for (int i = 0; i < childrenCount; i++) {
+                                    QTreeWidgetItem* child = restoredP->child(i);
+                                    if (!child) {
+                                        allChildrenNested = false;
+                                        break;
+                                    }
+                                }
+                                hierarchyPreserved = allChildrenNested;
+                            }
+                        }
+
+                        if (hierarchyPreserved) {
+                            TEST_PASS(itemType.name + ": Deep nested hierarchy preserved after undo");
+                        } else {
+                            TEST_FAIL(itemType.name + ": Deep nested hierarchy not preserved - children may be at root level");
+                        }
+                    } else {
+                        TEST_FAIL(itemType.name + ": Grandparent deletion failed");
+                    }
+                } else {
+                    TEST_FAIL(itemType.name + ": Failed to create parent folder");
+                }
+            } else {
+                TEST_FAIL(itemType.name + ": Failed to create grandparent folder");
+            }
+
+            CLEANUP_ALL(itemType);
+        }
+
         // Test: Stack command count consistency
         {
             int countBefore = editor->mpUndoStack->count();