Fix divide-by-zero vulnerability in NestedLearner

Addresses critical divide-by-zero errors in Train and AdaptToNewTask methods
when processing empty datasets.

## Issue

Both methods called _numOps.Divide(..., _numOps.FromDouble(dataList.Count))
without checking if dataList.Count == 0, causing runtime divide-by-zero errors.

## Locations Fixed

1. Train method (line 164): Computing average loss over training data
2. AdaptToNewTask method (line 228): Computing average new task loss

## Solution

Added empty dataset guards immediately after building dataList:

**Train method:**
- Returns MetaTrainingResult with:
  - FinalMetaLoss = Zero
  - FinalTaskLoss = Zero
  - FinalAccuracy = Zero
  - TotalIterations = current _globalStep
  - TotalTimeMs = elapsed time from stopwatch
  - Converged = false

**AdaptToNewTask method:**
- Returns MetaAdaptationResult with:
  - NewTaskLoss = Zero
  - ForgettingMetric = Zero
  - AdaptationSteps = 0
  - AdaptationTimeMs = elapsed time from stopwatch

## Behavior

- Preserves stopwatch timing (starts, stops, records elapsed time)
- Returns sensible default values for empty datasets
- No divide operations executed when count is zero
- Maintains method contracts and return types
- Does not throw exceptions for empty input (graceful handling)

## Impact

- ✅ Prevents runtime divide-by-zero errors
- ✅ Gracefully handles edge case of empty datasets
- ✅ Maintains timing accuracy
- ✅ Returns semantically correct results (zero loss for no data)

Author: claude

src/NestedLearning/NestedLearner.cs

@@ -145,6 +145,21 @@ public MetaTrainingResult<T> Train(
         var stopwatch = Stopwatch.StartNew();
         var dataList = trainingData.ToList();
 
+        // Guard against empty dataset
+        if (dataList.Count == 0)
+        {
+            stopwatch.Stop();
+            return new MetaTrainingResult<T>
+            {
+                FinalMetaLoss = _numOps.Zero,
+                FinalTaskLoss = _numOps.Zero,
+                FinalAccuracy = _numOps.Zero,
+                TotalIterations = _globalStep,
+                TotalTimeMs = stopwatch.Elapsed.TotalMilliseconds,
+                Converged = false
+            };
+        }
+
         T previousLoss = _numOps.FromDouble(double.MaxValue);
         int iterationsWithoutImprovement = 0;
         const int patience = 50;
@@ -205,6 +220,20 @@ public MetaAdaptationResult<T> AdaptToNewTask(
         _previousTaskParameters = _model.GetParameters().Clone();
 
         var dataList = newTaskData.ToList();
+
+        // Guard against empty dataset
+        if (dataList.Count == 0)
+        {
+            startTime.Stop();
+            return new MetaAdaptationResult<T>
+            {
+                NewTaskLoss = _numOps.Zero,
+                ForgettingMetric = _numOps.Zero,
+                AdaptationSteps = 0,
+                AdaptationTimeMs = startTime.Elapsed.TotalMilliseconds
+            };
+        }
+
         T newTaskLoss = _numOps.Zero;
         int adaptationSteps = 0;