Warn about trait bounds on struct and enum type parameters

Traits are for behavior.

impl<T> Data<T> where T: Behavior { /* behavior, okay */ }

fn behave<T>() where T: Behavior { /* also behavior, also okay */ }

struct Data<T> where T: Behavior { /* DON'T DO THIS */ }

The only exception is things like Cow that use associated types to define data.

My current understanding is that any data structure not using associated types should not have trait bounds (?Sized doesn't count). Redundant bounds like this suck because they transitively infect anything that names the type in any way. Consider this enum.

#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
enum Compact<T: CompactPart, H: Serialize + Deserialize + Clone + 'static> {
    Decrypted {
        header: Header<H>,
        payload: T,
    },
    Encrypted(Encrypted),
}

// kill me
fn print_the_thing<T, H>(c: Compact<T, H>)
    where T: CompactPart + Debug,
          H: Serialize + Deserialize + Clone + 'static + Debug
{
    println!("{:?}", c);
}

Without trait bounds on the data structure:

fn print_the_thing<T: Debug, H: Debug>(c: Compact<T, H>) {
    println!("{:?}", c);
}

Start from the Rust examples in the issue, including the linked src/jwe.rs example, and determine the intended cases for a warning on trait bounds attached to struct and enum type parameters. The payload names no Clippy implementation entry point or test file, so the completion criteria are the requested warning behavior and coverage for the shown valid and invalid patterns.