the trait bound X: Module is not satisfied

#[derive(Clone, Debug)]
enum Pooling {
  Mean,
  Max,
}

#[derive(Module, Debug)]
struct Head {
  linear: Linear,
  pooling: Pooling,
}

error[E0277]: the trait bound `Pooling: burn::module::Module` is not satisfied
  --> src/bin/skip_err.rs:10:10
   |
10 | #[derive(Module, Debug)]
   |          ^^^^^^ unsatisfied trait bound
   |
help: the trait `burn::module::Module` is not implemented for `Pooling`
  --> src/bin/skip_err.rs:5:1
   |
 5 | enum Pooling {
   | ^^^^^^^^^^^^
   = note: If `Pooling` is used as configuration or runtime state in a `#[derive(Module)]` type, mark that field with `#[module(skip)]`.
   = help: the following other types implement trait `burn::module::Module`:
             (L0, L1)
             (L0, L1, L2)
...
           and 124 others
   = note: this error originates in the derive macro `Module` (in Nightly builds, run with -Z macro-backtrace for more info)
...
error: could not compile `pb-pit` (bin "skip_err") due to 10 previous errors

#[derive(Module, Clone, Debug)]
struct Head {
  linear: Linear,
}

error[E0119]: conflicting implementations of trait `std::clone::Clone` for type `Head`
 --> src/bin/clone_err.rs:4:18
  |
4 | #[derive(Module, Clone, Debug)]
  |          ------  ^^^^^ conflicting implementation for `Head`
  |          |
  |          first implementation here

For more information about this error, try `rustc --explain E0119`.
error: could not compile `pb-pit` (bin "clone_err") due to 1 previous error

#[derive(Module, Debug)]
struct Head {
  linear: Linear,
  #[module(skip)]
  pooling: Pooling,
}

impl Head {
  fn forward(&self, x: Tensor<3>) -> Tensor<2> {
    let pooled = match self.pooling {
      Pooling::Mean => x.mean_dim(1),
      Pooling::Max => x.max_dim(1),
    };
    self.linear.forward(pooled.squeeze_dim(1))
  }
}

fn main() {
  let device = Device::flex();
  let head = Head { linear: LinearConfig::new(4, 2).init(&device), pooling: Pooling::Max };
  let out = head.forward(Tensor::<3>::ones([3, 5, 4], &device));
  println!("params {}, out {:?}", head.num_params(), out.dims());
  // the skipped field survives the module transforms, untouched
  let moved = head.valid().to_device(&Device::flex().autodiff());
  println!("after valid().to_device(..): pooling = {:?}", moved.pooling);
  println!("{moved}");
}

params 10, out [3, 2]
after valid().to_device(..): pooling = Max
Head {
  linear: Linear {d_input: 4, d_output: 2, bias: true, params: 10}
  pooling: Max
  params: 10
}