fix(networks): resnet/vgg train adds batch dim for 3d input

ResNet/VGG's Forward() explicitly accepts 3D [C,H,W] input and expands
it to 4D [1,C,H,W] before running the layer stack. Their Train()
overrides, however, called TrainWithTape directly — which delegates to
NeuralNetworkBase.ForwardForTraining, which does NOT add a batch dim
and just runs the raw tensor through every layer.

For a 3D input [3, 32, 32], the conv/pool chain preserves the rank-3
shape and the classifier's AdaptiveAveragePool + Flatten ends up
producing [512, 1] (the 512 final-block channel count gets treated as
a batch dim by FlattenLayer.Forward's "preserve first dim" rule). The
final DenseLayer with inputSize=512 sees actualInputSize=1 via
input.Shape[^1], calls EnsureWeightShapeForInput(1) which resizes
weights to [1, 10], and produces [512, 10] — which then fails the
loss shape check in EnsureTargetMatchesPredicted because the target
is [10].

Fix: mirror Forward()'s expansion in Train() — when input is 3D, add
a leading batch dim to BOTH input and target before dispatching to
TrainWithTape. Any 4D input is passed through untouched. The target
expansion is guarded so a caller that already provided a batched
target is not double-expanded.

Verified locally, all 4 of the previously-failing tests now pass:
  - ResNetNetwork_Train_CompletesWithoutError
  - ResNetNetwork_Train_LossDecreases
  - VGGNetwork_Train_CompletesWithoutError
  - VGGNetwork_Train_LossDecreases

Closes the 08a NN-Classic (ResNet/VGG/DenseNet) CI shard failure from
the PR #1154 triage.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ooples

src/NeuralNetworks/ResNetNetwork.cs

@@ -521,12 +521,29 @@ public override Tensor<T> Predict(Tensor<T> input)
     /// </summary>
     /// <param name="input">The input tensor for training.</param>
     /// <param name="expectedOutput">The expected output tensor (one-hot encoded class labels).</param>
+    /// <remarks>
+    /// Accepts both 3D <c>[C, H, W]</c> (single unbatched example) and 4D
+    /// <c>[B, C, H, W]</c> inputs — matches <see cref="Forward"/>'s contract.
+    /// When a 3D input arrives, a leading batch dimension is added so every
+    /// downstream layer sees the conv-standard 4D tensor. The corresponding
+    /// target is also expanded to <c>[1, numClasses]</c> so the loss sees
+    /// matching batch dims on both operands. Previously
+    /// <see cref="NeuralNetworkBase{T}.ForwardForTraining"/> fed the raw 3D
+    /// tensor straight to the layer stack, which caused the FlattenLayer to
+    /// treat the 512-channel dimension as a batch and produce a
+    /// <c>[512, 10]</c> prediction — failing the loss shape check in
+    /// <c>EnsureTargetMatchesPredicted</c>.
+    /// </remarks>
     public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
     {
         SetTrainingMode(true);
         try
         {
-            TrainWithTape(input, expectedOutput, _optimizer);
+            Tensor<T> processedInput = input.Rank == 3 ? AddBatchDimension(input) : input;
+            Tensor<T> processedTarget = input.Rank == 3 && expectedOutput.Rank < processedInput.Rank - 2
+                ? AddBatchDimension(expectedOutput)
+                : expectedOutput;
+            TrainWithTape(processedInput, processedTarget, _optimizer);
         }
         finally
         {

src/NeuralNetworks/VGGNetwork.cs

@@ -388,7 +388,18 @@ public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
         SetTrainingMode(true);
         try
         {
-            TrainWithTape(input, expectedOutput, _optimizer);
+            // Match Forward's behavior: accept 3D [C,H,W] single example and
+            // expand to 4D [1,C,H,W] so the layer stack (conv / pool / flatten /
+            // dense) receives the batched shape it expects. Without the
+            // expansion the FlattenLayer in the classifier head treats the
+            // channel dimension as a batch and produces an output with the
+            // wrong leading dim — fails the loss-shape check on every training
+            // call with a single 3D input.
+            Tensor<T> processedInput = input.Rank == 3 ? AddBatchDimension(input) : input;
+            Tensor<T> processedTarget = input.Rank == 3 && expectedOutput.Rank < processedInput.Rank - 2
+                ? AddBatchDimension(expectedOutput)
+                : expectedOutput;
+            TrainWithTape(processedInput, processedTarget, _optimizer);
         }
         finally
         {