labels: fresh-eyes audit — capture variant, dedupe detect, lock registry

Three targeted fixes from a second-pass audit of the labels module.

1. vocab::lang now returns Option<LangInfo> with both code AND a
   human-readable variant string. Pre-fix: 'Brazilian Portuguese 5.1'
   became language=por, variant='', dropping the dialect info the
   disc had explicitly authored. Post-fix: language=por,
   variant='Brazilian' — matches the convention pixelogic / ctrm /
   criterion already use for their region variants. dbp now
   populates StreamLabel::variant from this. Compound table grew a
   3-tuple (needle, code, variant); bare matches still return
   variant=''.

2. dbp and deluxe had duplicated detect() boilerplate (any top-level
   .jar in /BDMV/JAR/). Both now call jar::has_any_top_level_jar.
   The trait-level detect contract — see super::PARSERS — can't peek
   inside a jar without a SectorReader, so loose-detect-plus-real-
   check-in-parse is the unavoidable pattern for jar-content parsers.
   Consolidating in jar.rs at least makes the duplication visible.

3. mod.rs comment about parser ordering said 'dbp last'; deluxe is
   actually now last. Updated to explain the dbp-before-deluxe order
   is by cost (cp-iteration cheaper than bytecode walking when Phase
   D lands).

Plus a registry-level lock test in mod.rs::registry_tests — asserts
the PARSERS array order is exactly [paramount, criterion, pixelogic,
ctrm, dbp, deluxe]. This was previously implicit; if someone reorders
the array (which changes which parser wins on overlapping signals),
unit tests would have stayed green. Now they fail with an explanatory
message about why the order matters.

Audit findings deferred to follow-ups (each its own commit + design
discussion):
- Stronger detect contract — current loose-detect-real-check pattern
  is forced by SectorReader-not-in-detect-signature; could be fixed
  by changing the trait to take an Option<&mut dyn SectorReader> or
  similar.
- Per-parser confidence scoring — registry currently first-match-wins.
  A high-confidence parser ought to beat a low-confidence one
  regardless of array order.
- class_reader fuzzing — handles malformed input via Result but no
  adversarial corpus yet.

Precommit (cargo +1.86 fmt + clippy + test) green.

src/labels/dbp.rs

@@ -46,13 +46,7 @@ use std::collections::BTreeMap;
 /// returns None on a mismatch — so this parser only ever consumes
 /// time on discs that fell through every earlier parser.
 pub fn detect(udf: &UdfFs) -> bool {
-    let Some(jar_dir) = udf.find_dir("/BDMV/JAR") else {
-        return false;
-    };
-    jar_dir
-        .entries
-        .iter()
-        .any(|e| !e.is_dir && e.name.to_lowercase().ends_with(".jar"))
+    jar::has_any_top_level_jar(udf)
 }
 
 pub fn parse(reader: &mut dyn SectorReader, udf: &UdfFs) -> Option<Vec<StreamLabel>> {
@@ -129,7 +123,9 @@ fn collect_textfield(
 }
 
 fn make_label(num: u16, label: String, stream_type: StreamLabelType) -> StreamLabel {
-    let language = vocab::lang(&label).unwrap_or_default().to_string();
+    let lang_info = vocab::lang(&label);
+    let language = lang_info.map(|l| l.code).unwrap_or("").to_string();
+    let variant = lang_info.map(|l| l.variant).unwrap_or("").to_string();
     let qualifier = vocab::qualifier(&label);
     let purpose = vocab::purpose(&label);
     StreamLabel {
@@ -140,7 +136,7 @@ fn make_label(num: u16, label: String, stream_type: StreamLabelType) -> StreamLa
         purpose,
         qualifier,
         codec_hint: String::new(),
-        variant: String::new(),
+        variant,
     }
 }
 
@@ -221,31 +217,37 @@ mod tests {
     }
 
     #[test]
-    fn make_label_compound_languages() {
-        assert_eq!(
-            make_label(1, "Brazilian Portuguese 5.1".into(), StreamLabelType::Audio).language,
-            "por"
-        );
-        assert_eq!(
-            make_label(1, "Castilian Spanish".into(), StreamLabelType::Audio).language,
-            "spa"
-        );
-        assert_eq!(
-            make_label(
-                1,
-                "Canadian French Dolby Digital".into(),
-                StreamLabelType::Audio
-            )
-            .language,
-            "fra"
+    fn make_label_compound_languages_populate_variant() {
+        let brazilian = make_label(1, "Brazilian Portuguese 5.1".into(), StreamLabelType::Audio);
+        assert_eq!(brazilian.language, "por");
+        assert_eq!(brazilian.variant, "Brazilian");
+
+        let castilian = make_label(1, "Castilian Spanish".into(), StreamLabelType::Audio);
+        assert_eq!(castilian.language, "spa");
+        assert_eq!(castilian.variant, "Castilian");
+
+        let canadian = make_label(
+            1,
+            "Canadian French Dolby Digital".into(),
+            StreamLabelType::Audio,
         );
+        assert_eq!(canadian.language, "fra");
+        assert_eq!(canadian.variant, "Canadian");
+    }
+
+    #[test]
+    fn make_label_bare_language_has_empty_variant() {
+        let l = make_label(1, "English Dolby Atmos".into(), StreamLabelType::Audio);
+        assert_eq!(l.language, "eng");
+        assert_eq!(l.variant, "");
     }
 
     #[test]
     fn make_label_unknown_language_is_empty() {
-        // vocab::lang returns None — make_label converts to "".
+        // vocab::lang returns None — make_label converts both fields to "".
         let l = make_label(1, "Klingon Dolby Atmos".into(), StreamLabelType::Audio);
         assert_eq!(l.language, "");
+        assert_eq!(l.variant, "");
     }
 
     #[test]