Record Deserializer not implemented for enum

[laggui]

Describe the bug
I stumbled upon this issue when importing a PyTorch model with PyTorchFileRecorder to load it into the Burn equivalent definition.

The PyTorch model defines a module that depends on a condition (returns a conv block in one case, and depthwise conv block in the other). For that, I implemented the block as an enum since #1337 landed. But it fails with this error:

thread 'main' panicked at burn/crates/burn-core/src/record/serde/de.rs:325:9:
not implemented: deserialize_enum is not implemented
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Straight from unimplemented!("deserialize_enum is not implemented") in de.rs

Would be nice to add support to deserialize with enums now that they are supported for modules.

MWE

import torch
from torch import nn, Tensor

class DwsConv(nn.Module):
    """Depthwise separable convolution."""

    def __init__(self, in_channels: int, out_channels: int, kernel_size: int) -> None:
        super().__init__()
        # Depthwise conv
        self.dconv = nn.Conv2d(in_channels, in_channels, kernel_size, groups=in_channels)
        # Pointwise conv
        self.pconv = nn.Conv2d(in_channels, out_channels, kernel_size=1, groups=1)

    def forward(self, x: Tensor) -> Tensor:
        x = self.dconv(x)
        return self.pconv(x)


class Net(nn.Module):
    def __init__(self, depthwise: bool = False) -> None:
        super().__init__()
        self.conv = DwsConv(3, 64, 3) if depthwise else nn.Conv2d(3, 64, 3)


if __name__ == "__main__":
    torch.manual_seed(42)  # To make it reproducible
    model = Net(depthwise=True)
    model_weights = model.state_dict()
    torch.save(model_weights, "conv-dws.pt")

use burn::{
    backend::{ndarray::NdArrayDevice, NdArray},
    module::Module,
    nn::conv::{Conv2d, Conv2dConfig},
    record::{FullPrecisionSettings, Recorder},
    tensor::backend::Backend,
};
use burn_import::pytorch::PyTorchFileRecorder;

#[derive(Module, Debug)]
pub enum Conv<B: Backend> {
    DwsConv(DwsConv<B>),
    Conv(Conv2d<B>),
}

#[derive(Module, Debug)]
pub struct DwsConv<B: Backend> {
    dconv: Conv2d<B>,
    pconv: Conv2d<B>,
}

#[derive(Module, Debug)]
pub struct Net<B: Backend> {
    conv: Conv<B>,
}

fn main() {
    let device = NdArrayDevice::default();
    let model: Net<NdArray> = Net {
        conv: Conv::Conv(Conv2dConfig::new([3, 64], [3, 3]).init(&device)),
    };

    let record = PyTorchFileRecorder::<FullPrecisionSettings>::new()
        .load("conv-dws.pt".into(), &device)
        .unwrap();

    model.load_record(record);
}

[laggui]

@antimora tagging since you worked on this in the past. We can discuss this offline, would like to get your opinion.

[antimora]

@laggui , yes, I agree we should support it.

[antimora]

serde-rs/serde#2187

serde-rs/serde#2473 (comment)