fix(shadows): support opaque newtype variants in adjacently-tagged enums

[KennethKnudsen97]

Summary

• Adjacently-tagged shadow enums with a #[shadow_attr(opaque)] newtype variant (e.g. Manual(heapless::String<62>)) now compile and round-trip cleanly to a flat wire shape {"mode":"manual","apn":"onomondo"}.
• Skips the From<<T as ShadowNode>::Reported> for Reported<Enum> impls (and the matching Delta) when the variant field is opaque — for leaf types where Delta = Reported = Self the projection collapses to From<X> for X and collides with impl<T> From<T> for T (E0119).
• Emits a scalar serialize arm (map.serialize_entry(content_key, content)) for opaque variants instead of the ContentWrapper nested-map approach, and drops opaque variants from the inactive-variant null-padding list so sibling unit variants don't emit empty content maps.
• Same opaque gating is applied to the externally-tagged enum codegen for symmetry.

The existing struct-inner-type path (PortMode::Sio(SioConfig), WifiAuth::Wpa2(WpaConfig)) is unchanged and still produces {"mode":"sio","config":{…}}.

Stacked on feat/subscription-disconnect-aware. Targeting that branch — change base after it lands.

Test plan

• cargo test --lib --features "std,log" → 164 passed (7 new opaque tests).
• cargo test -p rustot-derive → 10 passed.
• cargo build --no-default-features → clean.
• cargo build --no-default-features --features "shadows_kv_persist" → clean.
• All 24 pre-existing adjacently_tagged tests still pass (PortMode struct-inner-type path unchanged).

[MathiasKoch]

Recommendation: require #[shadow_attr(opaque)] and drop the trait-based detection

The two codegen paths in this PR use different dispatch criteria:

• From impls (adjacently_tagged.rs:233, enum_codegen.rs mirror) dispatch on FieldAttrs::is_opaque() — i.e. the attribute.
• Serialize arm (adjacently_tagged.rs:591-614) dispatches at const-eval on <<T as ShadowNode>::Reported as ReportedFields>::FIELD_NAMES.is_empty() — i.e. the trait.

This split has a sharp edge: an external consumer who writes Mode(heapless::String<32>) without #[shadow_attr(opaque)] gets correct serialization but a compile failure on the generated From impl, because rustc only normalizes <T as ShadowNode>::Reported through local impls inside the defining crate. The PR description acknowledges this. The 7 added tests cannot regress it because they live in-crate.

Proposal

Require #[shadow_attr(opaque)] on the variant field and drop the const-eval detection. Both codegen paths then dispatch on the attribute at macro-expansion time.

Concrete consequences in adjacently_tagged.rs:

1. The __INNER_IS_OPAQUE const and the surrounding if/else collapse. The opaque newtype arm becomes:

   Self::#variant_ident(ref content) => {
       map.serialize_entry(#tag_key, #serde_name)?;
       map.serialize_entry(#content_key, content)?;
   }

   The non-opaque arm keeps the existing ContentWrapper path. No more dead ContentWrapper definition emitted in opaque arms.
2. inactive_variant_field_nulls only collects non-opaque siblings, filtered at codegen. has_non_opaque_sibling reduces to a plain bool known at codegen, dropping the __HAS_NON_OPAQUE_SIBLING const-expression-of-projections.
3. Failure mode for a missing attribute becomes consistent: serialize tries the ContentWrapper path on a leaf type and trips a first-round-trip test, instead of silently going one way and breaking only at a downstream consumer.

Trade-off: users must remember the attribute. That's already true for struct-field opaqueness — the burden becomes consistent, not new.

Secondary

• Add an out-of-crate compile test for the E0119 fix. A trybuild test under rustot_derive/tests/ consuming an opaque newtype variant would actually pin down the bug this PR fixes. The 7 in-crate tests prove the new serialize/parse paths work, but cannot regress the original collision.
• Update OpaqueSpec docs in rustot_derive/src/attr/field_attr.rs. Today they describe only the struct-field meaning. After this PR the attribute on a variant field controls (a) flat wire format and (b) suppression of the projected From impl. Document both, and confirm whether MaxSize is still required for the variant-field use.
• Confirm GH base is master before merge. PR description references feat/subscription-disconnect-aware (landed as #123). Diff stat against master is clean, so the rebase looks done — just flip the base in the GH UI.

[KennethKnudsen97]

Addressed in defe840. Took the recommendation: dropped the const-eval trait-based dispatch and made both code paths (From impls + serialize arm) read #[shadow_attr(opaque)] at macro-expansion time.

Codegen (adjacently_tagged.rs)

• __INNER_IS_OPAQUE and the surrounding if/else collapsed — opaque newtype variants now emit just map.serialize_entry(content_key, content). Non-opaque keep the ContentWrapper path. No more dead ContentWrapper definition in opaque arms.
• __HAS_NON_OPAQUE_SIBLING is now a plain codegen-time bool (!inactive_variant_field_nulls.is_empty()); inactive_variant_field_nulls is filtered to non-opaque siblings up front.
• Unit variant with no non-opaque siblings emits just the tag (no empty content map).

Tests (tests.rs)

• Label(heapless::String<16>) → Label(#[shadow_attr(opaque)] heapless::String<16>). Same for Named (in OpaqueEnum) and Number(u32) (in IntEnum).
• Reworded the comment on test_from_impls_emitted_for_all_data_variants so it accurately describes which arm each variant exercises (Toggle → projection arm, Label → direct arm).

Docs (field_attr.rs)

• OpaqueSpec and the opaque field doc-comment now describe the variant-field meaning (flat wire shape + From-impl gating to dodge E0119) alongside the existing struct-field meaning.

Verification

• cargo test --lib --features "std,log" → 173 passed.
• cargo test -p rustot-derive → 10 passed.
• cargo build --no-default-features and --features "shadows_kv_persist" → clean.

Not done (from the secondary list)

• Out-of-crate trybuild test for the E0119 fix — would add new test infrastructure for one assertion. Happy to do it as a follow-up if you want it pinned down.
• GH base flip — diff against master is clean, so just a UI action whenever you're ready.