feat: Update SplitLayer to use Reshape TensorOperation

SplitLayer now uses the existing Reshape operation for autodiff backward pass.

Key features:
- Uses existing Reshape operation (no new operation needed)
- Split operation in this layer is effectively a reshape: [batch, size] → [batch, numSplits, size/numSplits]
- Full autodiff support with gradient computation

Layers with autodiff: 20 (19 previous + 1 new)

Author: claude

src/NeuralNetworks/Layers/SplitLayer.cs

@@ -254,14 +254,80 @@ private Tensor<T> BackwardManual(Tensor<T> outputGradient)
     /// <returns>The gradient of the loss with respect to the layer's input.</returns>
     /// <remarks>
     /// <para>
-    /// This method uses automatic differentiation to compute gradients. Specialized operations
-    /// are not yet available in TensorOperations, so this falls back to the manual implementation.
+    /// This method uses automatic differentiation to compute gradients using the Reshape operation.
+    /// The split layer is effectively a reshape operation that adds a new dimension by dividing
+    /// one dimension into two.
     /// </para>
     /// </remarks>
     private Tensor<T> BackwardViaAutodiff(Tensor<T> outputGradient)
     {
-        // TODO: Specialized operation not yet available in TensorOperations
-        return BackwardManual(outputGradient);
+        if (_lastInput == null)
+            throw new InvalidOperationException("Forward pass must be called before backward pass.");
+
+        // Create computation node
+        var inputNode = Autodiff.TensorOperations<T>.Variable(_lastInput, "input", requiresGradient: true);
+
+        // Split is effectively a reshape: [batch, inputSize] → [batch, numSplits, splitSize]
+        int batchSize = _lastInput.Shape[0];
+        int inputSize = _lastInput.Shape[1];
+        int splitSize = inputSize / _numSplits;
+        var outputShape = new int[] { batchSize, _numSplits, splitSize };
+
+        var outputNode = Autodiff.TensorOperations<T>.Reshape(inputNode, outputShape);
+
+        // Perform backward pass
+        outputNode.Gradient = outputGradient;
+        var topoOrder = GetTopologicalOrder(outputNode);
+        for (int i = topoOrder.Count - 1; i >= 0; i--)
+        {
+            var node = topoOrder[i];
+            if (node.RequiresGradient && node.BackwardFunction != null && node.Gradient != null)
+            {
+                node.BackwardFunction(node.Gradient);
+            }
+        }
+
+        // Extract input gradient
+        return inputNode.Gradient ?? throw new InvalidOperationException("Gradient computation failed.");
+    }
+
+    /// <summary>
+    /// Gets the topological order of nodes in the computation graph.
+    /// </summary>
+    /// <param name="root">The root node of the computation graph.</param>
+    /// <returns>A list of nodes in topological order.</returns>
+    private List<Autodiff.ComputationNode<T>> GetTopologicalOrder(Autodiff.ComputationNode<T> root)
+    {
+        var visited = new HashSet<Autodiff.ComputationNode<T>>();
+        var result = new List<Autodiff.ComputationNode<T>>();
+
+        var stack = new Stack<(Autodiff.ComputationNode<T> node, bool processed)>();
+        stack.Push((root, false));
+
+        while (stack.Count > 0)
+        {
+            var (node, processed) = stack.Pop();
+
+            if (visited.Contains(node))
+                continue;
+
+            if (processed)
+            {
+                visited.Add(node);
+                result.Add(node);
+            }
+            else
+            {
+                stack.Push((node, true));
+                foreach (var parent in node.Parents)
+                {
+                    if (!visited.Contains(parent))
+                        stack.Push((parent, false));
+                }
+            }
+        }
+
+        return result;
     }