feat: integrate VisualTreeHelper for WPF visual tree traversal parity

- Added `VisualTreeHelper.cs` to expose `GetChildrenCount`, `GetChild`, and `GetParent`.
- Delegated logic to existing `UIElement` methods `VisualChildrenCount`, `GetVisualChild`, and `Parent`.
- Added accompanying unit tests in `VisualTreeHelperTests`.

Co-authored-by: tedd <493224+tedd@users.noreply.github.com>

Author: google-labs-jules[bot]

.jules/forge.md

@@ -142,3 +142,10 @@
 - Systematically removed `OnDataContextChanged` overrides in `Border`, `DialogBox`, `Table`, `TuiWindow`, and `Grid`.
 - Removed explicit `DataContext` local value setters when assigning child elements (e.g., `PushOverlay` in `TuiWindow.cs`, `Content` setter in `DialogBox.cs`).
 - Delegated context propagation fully to `UIElement.OnPropertyChanged` which naturally handles `IsInherited` property traversal, matching the exact WPF hierarchical structure and eliminating false-positive `HasLocalValue` states on visual children.
+
+## 2024-05-15 - VisualTreeHelper Parity Integration
+**Observation:** Discovered a parity deficit where the `VisualTreeHelper` utility class was completely missing. The TUI framework exposed `VisualChildrenCount` and `GetVisualChild` directly on `UIElement`, but WPF delegates visual tree traversal explicitly to the `VisualTreeHelper` API to decouple the logical/visual tree navigation mechanisms from individual component interfaces.
+**Strategic Action:**
+- Engineered the `VisualTreeHelper` static class.
+- Implemented standard visual tree traversal methods `GetChildrenCount`, `GetChild`, and `GetParent`.
+- Delegated the calls to the existing `VisualChildrenCount`, `GetVisualChild`, and `Parent` infrastructure on `UIElement`, bringing the framework structurally closer to standard XAML paradigms for visual hit-testing and control template tree navigation.

src/Tedd.TUI.Tests/VisualTreeHelperTests.cs

@@ -0,0 +1,60 @@
+using System;
+using Xunit;
+using Tedd.TUI;
+
+namespace Tedd.TUI.Tests
+{
+    public class VisualTreeHelperTests
+    {
+        [Fact]
+        public void GetChildrenCount_NullReference_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>(() => VisualTreeHelper.GetChildrenCount(null!));
+        }
+
+        [Fact]
+        public void GetChild_NullReference_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>(() => VisualTreeHelper.GetChild(null!, 0));
+        }
+
+        [Fact]
+        public void GetParent_NullReference_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>(() => VisualTreeHelper.GetParent(null!));
+        }
+
+        [Fact]
+        public void GetChildrenCount_ReturnsVisualChildrenCount()
+        {
+            var panel = new StackPanel();
+            panel.Children.Add(new Button());
+            panel.Children.Add(new TextBlock());
+
+            Assert.Equal(2, VisualTreeHelper.GetChildrenCount(panel));
+        }
+
+        [Fact]
+        public void GetChild_ReturnsVisualChild()
+        {
+            var panel = new StackPanel();
+            var button = new Button();
+            var textBlock = new TextBlock();
+            panel.Children.Add(button);
+            panel.Children.Add(textBlock);
+
+            Assert.Same(button, VisualTreeHelper.GetChild(panel, 0));
+            Assert.Same(textBlock, VisualTreeHelper.GetChild(panel, 1));
+        }
+
+        [Fact]
+        public void GetParent_ReturnsParent()
+        {
+            var panel = new StackPanel();
+            var button = new Button();
+            panel.Children.Add(button);
+
+            Assert.Same(panel, VisualTreeHelper.GetParent(button));
+        }
+    }
+}

src/Tedd.TUI/VisualTreeHelper.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using Tedd.TUI;
+
+namespace Tedd.TUI
+{
+    public static class VisualTreeHelper
+    {
+        public static int GetChildrenCount(UIElement reference)
+        {
+            if (reference == null) throw new ArgumentNullException(nameof(reference));
+            return reference.VisualChildrenCount;
+        }
+
+        public static UIElement GetChild(UIElement reference, int childIndex)
+        {
+            if (reference == null) throw new ArgumentNullException(nameof(reference));
+            return reference.GetVisualChild(childIndex);
+        }
+
+        public static UIElement? GetParent(UIElement reference)
+        {
+            if (reference == null) throw new ArgumentNullException(nameof(reference));
+            return reference.Parent; // TUI maps VisualParent to Parent mostly, or maybe we need a dedicated VisualParent in the future?
+        }
+    }
+}