Allow generic arguments in enum variants

[AlephAlpha]

Allow generic arguments in enum variants, for example:

#[proxy_enum::proxy(Animal)]
mod proxy {
    use super::{Cat, Foo, Lion, Mouse};

    enum Animal {
        Cat(Cat<Foo>),
        Lion(Lion),
        Mouse(Mouse),
    }

    impl Animal {
        #[implement]
        fn feed(&self) {}
    }
}

This would expand to:

mod proxy {
    use super::{Cat, Foo, Lion, Mouse};
    enum Animal {
        Cat(Cat<Foo>),
        Lion(Lion),
        Mouse(Mouse),
    }
    impl Animal {
        fn feed(&self) {
            match self {
                Self::Cat(__self) => <Cat<Foo>>::feed(__self),
                Self::Lion(__self) => <Lion>::feed(__self),
                Self::Mouse(__self) => <Mouse>::feed(__self),
            }
        }
    }
    impl From<Cat<Foo>> for Animal {
        fn from(from: Cat<Foo>) -> Self {
            Animal::Cat(from)
        }
    }
    impl From<Lion> for Animal {
        fn from(from: Lion) -> Self {
            Animal::Lion(from)
        }
    }
    impl From<Mouse> for Animal {
        fn from(from: Mouse) -> Self {
            Animal::Mouse(from)
        }
    }
}

The < and > around the type are only added for inherent implementations, not trait implementations.

[AlephAlpha]

Sorry for my username. It's just a coincidence.