feat: add display UI with splash screen, dashboard, and RSSI sparkline

Implement full SSD1306 OLED display support:
- Splash screen on boot (1.5s) with project name, version, board
- Dashboard showing radio state, config, counters, RSSI/SNR
- RSSI history sparkline (64-sample ring buffer, 2px-wide bars)
- DisplayOn/DisplayOff host commands routed via dedicated channel
- Pure render functions against generic DrawTarget (no hardware coupling)
- Display on/off control bypasses radio task entirely

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

vendor/darling-0.20.11/tests/from_meta.rs

@@ -0,0 +1,304 @@
+use darling::{Error, FromMeta};
+use syn::parse_quote;
+
+#[derive(Debug, FromMeta)]
+struct Meta {
+    #[darling(default)]
+    meta1: Option<String>,
+    #[darling(default)]
+    meta2: bool,
+}
+
+#[test]
+fn nested_meta_meta_value() {
+    let meta = Meta::from_list(&[parse_quote! {
+        meta1 = "thefeature"
+    }])
+    .unwrap();
+    assert_eq!(meta.meta1, Some("thefeature".to_string()));
+    assert!(!meta.meta2);
+}
+
+#[test]
+fn nested_meta_meta_bool() {
+    let meta = Meta::from_list(&[parse_quote! {
+        meta2
+    }])
+    .unwrap();
+    assert_eq!(meta.meta1, None);
+    assert!(meta.meta2);
+}
+
+#[test]
+fn nested_meta_lit_string_errors() {
+    let err = Meta::from_list(&[parse_quote! {
+        "meta2"
+    }])
+    .unwrap_err();
+    assert_eq!(
+        err.to_string(),
+        Error::unsupported_format("literal").to_string()
+    );
+}
+
+#[test]
+fn nested_meta_lit_integer_errors() {
+    let err = Meta::from_list(&[parse_quote! {
+        2
+    }])
+    .unwrap_err();
+    assert_eq!(
+        err.to_string(),
+        Error::unsupported_format("literal").to_string()
+    );
+}
+
+#[test]
+fn nested_meta_lit_bool_errors() {
+    let err = Meta::from_list(&[parse_quote! {
+        true
+    }])
+    .unwrap_err();
+    assert_eq!(
+        err.to_string(),
+        Error::unsupported_format("literal").to_string()
+    );
+}
+
+/// Tests behavior of FromMeta implementation for enums.
+mod enum_impl {
+    use darling::{Error, FromMeta};
+    use syn::parse_quote;
+
+    /// A playback volume.
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, FromMeta)]
+    enum Volume {
+        Normal,
+        Low,
+        High,
+        #[darling(rename = "dB")]
+        Decibels(u8),
+    }
+
+    #[test]
+    fn string_for_unit_variant() {
+        let volume = Volume::from_string("low").unwrap();
+        assert_eq!(volume, Volume::Low);
+    }
+
+    #[test]
+    fn single_value_list() {
+        let unit_variant = Volume::from_list(&[parse_quote!(high)]).unwrap();
+        assert_eq!(unit_variant, Volume::High);
+
+        let newtype_variant = Volume::from_list(&[parse_quote!(dB = 100)]).unwrap();
+        assert_eq!(newtype_variant, Volume::Decibels(100));
+    }
+
+    #[test]
+    fn empty_list_errors() {
+        let err = Volume::from_list(&[]).unwrap_err();
+        assert_eq!(err.to_string(), Error::too_few_items(1).to_string());
+    }
+
+    #[test]
+    fn multiple_values_list_errors() {
+        let err = Volume::from_list(&[parse_quote!(low), parse_quote!(dB = 20)]).unwrap_err();
+        assert_eq!(err.to_string(), Error::too_many_items(1).to_string());
+    }
+}
+
+mod from_none_struct_closure {
+    use darling::FromMeta;
+    use syn::parse_quote;
+
+    #[derive(Debug, FromMeta)]
+    struct Outer {
+        // Do NOT add `darling(default)` here; this is testing the `from_none` fallback
+        // invoked when a field is not declared and no `default` is specified.
+        speech: Example,
+    }
+
+    #[derive(Debug, FromMeta)]
+    #[darling(from_none = || Some(Default::default()))]
+    struct Example {
+        max_volume: u32,
+    }
+
+    impl Default for Example {
+        fn default() -> Self {
+            Example { max_volume: 3 }
+        }
+    }
+
+    #[test]
+    fn absent_gets_from_none() {
+        let thing = Outer::from_list(&[]).unwrap();
+        assert_eq!(thing.speech.max_volume, 3);
+    }
+
+    #[test]
+    fn word_errors() {
+        let error = Outer::from_list(&[parse_quote!(speech)])
+            .expect_err("speech should require its fields if declared");
+        assert_eq!(error.len(), 1);
+    }
+
+    #[test]
+    fn list_sets_field() {
+        let thing = Outer::from_list(&[parse_quote!(speech(max_volume = 5))]).unwrap();
+        assert_eq!(thing.speech.max_volume, 5);
+    }
+}
+
+mod from_none_struct_path {
+    use darling::FromMeta;
+    use syn::parse_quote;
+
+    #[derive(Debug, FromMeta)]
+    struct Outer {
+        // Do NOT add `darling(default)` here; this is testing the `from_none` fallback
+        // invoked when a field is not declared and no `default` is specified.
+        speech: Example,
+    }
+
+    fn from_none_fallback() -> Option<Example> {
+        Some(Example { max_volume: 3 })
+    }
+
+    #[derive(Debug, FromMeta)]
+    #[darling(from_none = from_none_fallback)]
+    struct Example {
+        max_volume: u32,
+    }
+
+    #[test]
+    fn absent_gets_from_none() {
+        let thing = Outer::from_list(&[]).unwrap();
+        assert_eq!(thing.speech.max_volume, 3);
+    }
+
+    #[test]
+    fn word_errors() {
+        let error = Outer::from_list(&[parse_quote!(speech)])
+            .expect_err("speech should require its fields if declared");
+        assert_eq!(error.len(), 1);
+    }
+
+    #[test]
+    fn list_sets_field() {
+        let thing = Outer::from_list(&[parse_quote!(speech(max_volume = 5))]).unwrap();
+        assert_eq!(thing.speech.max_volume, 5);
+    }
+}
+
+mod from_word_struct_closure {
+    use darling::FromMeta;
+    use syn::parse_quote;
+
+    #[derive(FromMeta)]
+    struct Outer {
+        #[darling(default)]
+        speech: Example,
+    }
+
+    #[derive(FromMeta, Default)]
+    #[darling(from_word = || Ok(Example { max_volume: 10 }))]
+    struct Example {
+        max_volume: u32,
+    }
+
+    #[test]
+    fn absent_gets_default() {
+        let thing = Outer::from_list(&[]).unwrap();
+        assert_eq!(thing.speech.max_volume, 0);
+    }
+
+    #[test]
+    fn word_gets_value() {
+        let thing = Outer::from_list(&[parse_quote!(speech)]).unwrap();
+        assert_eq!(thing.speech.max_volume, 10);
+    }
+
+    #[test]
+    fn list_sets_field() {
+        let thing = Outer::from_list(&[parse_quote!(speech(max_volume = 5))]).unwrap();
+        assert_eq!(thing.speech.max_volume, 5);
+    }
+}
+
+mod from_word_struct_path {
+    use darling::FromMeta;
+    use syn::parse_quote;
+
+    #[derive(FromMeta)]
+    struct Outer {
+        #[darling(default)]
+        speech: Example,
+    }
+
+    fn max_volume_10() -> darling::Result<Example> {
+        Ok(Example { max_volume: 10 })
+    }
+
+    #[derive(FromMeta, Default)]
+    #[darling(from_word = max_volume_10)]
+    struct Example {
+        max_volume: u32,
+    }
+
+    #[test]
+    fn absent_gets_default() {
+        let thing = Outer::from_list(&[]).unwrap();
+        assert_eq!(thing.speech.max_volume, 0);
+    }
+
+    #[test]
+    fn word_gets_value() {
+        let thing = Outer::from_list(&[parse_quote!(speech)]).unwrap();
+        assert_eq!(thing.speech.max_volume, 10);
+    }
+
+    #[test]
+    fn list_sets_field() {
+        let thing = Outer::from_list(&[parse_quote!(speech(max_volume = 5))]).unwrap();
+        assert_eq!(thing.speech.max_volume, 5);
+    }
+}
+
+mod from_word_enum_closure {
+    use darling::FromMeta;
+    use syn::parse_quote;
+
+    #[derive(Debug, FromMeta)]
+    struct Outer {
+        speech: Example,
+    }
+
+    #[derive(Debug, FromMeta, PartialEq, Eq)]
+    #[darling(from_word = || Ok(Example::Left { max_volume: 10 }))]
+    enum Example {
+        Left { max_volume: u32 },
+        Right { speed: u32 },
+    }
+
+    #[test]
+    fn word_gets_value() {
+        let thing = Outer::from_list(&[parse_quote!(speech)]).unwrap();
+        assert_eq!(thing.speech, Example::Left { max_volume: 10 });
+    }
+
+    #[test]
+    fn list_sets_field() {
+        let thing = Outer::from_list(&[parse_quote!(speech(left(max_volume = 5)))]).unwrap();
+        assert_eq!(thing.speech, Example::Left { max_volume: 5 });
+    }
+
+    #[test]
+    fn variant_word_fails() {
+        let thing = Outer::from_list(&[parse_quote!(speech(left))]).expect_err(
+            "A variant word is an error because from_word applies at the all-up enum level",
+        );
+        assert_eq!(thing.len(), 1);
+    }
+}