fix: ensure zero_grad is called before backward in Autoencoder._learn

[GoBeromsu]

Thank you for the interesting project. While reviewing the code, I discovered a gradient management issue specific to the Autoencoder._learn method.

Initially, I thought the current gradient update sequence might be a deliberate design pattern. However, after inspecting other components, I found that all other learning processes follow the correct PyTorch order:
zero_grad() → backward() → step().

In contrast, the Autoencoder currently performs:
backward() → step() → zero_grad(),
which can cause gradient leakage if an exception is raised between backward() and zero_grad().

Test code

def test_autoencoder_learn_one():
    """Test that learn_one() properly handles gradient clearing after exceptions
    
    This test verifies:
    1. When learn_one() encounters an exception during backward(), it leaves gradients computed
    2. On the next learn_one() call, those gradients are properly cleared before new computation
    3. The final gradients are valid and not accumulated from the previous failed attempt
    
    This ensures the optimization cycle (zero_grad → backward → step) works correctly
    even when interrupted by exceptions.
    """

    ae = Autoencoder(module=_TestAutoencoder, optimizer_fn="sgd")

    # Simulate a crash during backward pass
    original_backward = torch.Tensor.backward

    def patched_backward(self, *args, **kwargs):
        original_backward(self, *args, **kwargs)
        raise RuntimeError("Simulated exception during backward pass")

    torch.Tensor.backward = patched_backward

    try:
        # First learn_one call - will raise exception after computing gradients
        with pytest.raises(RuntimeError):
            ae.learn_one({'feature1': 0.2, 'feature2': 0.8})
    finally:
        # Always restore the original function
        torch.Tensor.backward = original_backward

    # Second learn_one call should succeed and start with clean gradients
    ae.learn_one({'feature1': 0.1, 'feature2': 0.9})

    # Verify:
    # 1. New gradients were computed (not None)
    # 2. They are valid (finite values)
    # 3. They represent a meaningful update (not all zeros)
    for param in ae.module.parameters():
        assert param.grad is not None, "learn_one() should compute gradients"
        assert torch.all(torch.isfinite(param.grad)), "learn_one() should produce finite gradients"
        assert not torch.all(param.grad == 0), "learn_one() should produce non-zero gradients"

[kulbachcedric]

Hi @GoBeromsu,
Thanks for the hint and the fix!
I'll merge this PR and open a new issue to add more precise tests for every estimator (every lern_* method). As we are currently mostly using test from the river framework, I'd like to build a similar but mor specific test framework for deep-river.

Best,
Cedric

[GoBeromsu]

Thank you :)