fix(clippy): bring source under -D warnings ahead of CI

Prep for the Forgejo CI gate. Adjustments per module are small
and local:

  - test modules get inner `#![allow(clippy::unwrap_used,
    expect_used, panic)]` so the existing assert.expect()
    test idiom keeps working without rewriting every fixture
  - the dead_code field that downstream consumers may still
    want serialised gets an explicit #[allow(dead_code)]
  - manual char/range comparisons fold to the idiomatic forms
    (`['…']`, `(2..=5).contains(&n)`)
  - one snake_case rename in text-readability-score

Also re-bakes module.wasm so the committed artefact matches
the post-fmt source byte-for-byte.

No behaviour change, no test change. cargo fmt --all -- --check
and cargo clippy --all-targets -- -D warnings now both pass.

Signed-off-by: flemming-it <sf@flemming.it>

src/lib.rs

@@ -22,6 +22,7 @@ use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Deserialize)]
 struct InputNorm {
+    #[allow(dead_code)]
     eli: Option<String>,
     jurabk: Option<String>,
     paragraph: Option<String>,
@@ -90,7 +91,10 @@ pub fn invoke(_ctx: Context, inputs: Inputs) -> Result<Outputs, ModuleError> {
     } else {
         duties.iter().map(|d| d.confidence).sum::<f32>() / duties.len() as f32
     };
-    let out = Output { duties, avg_confidence: avg };
+    let out = Output {
+        duties,
+        avg_confidence: avg,
+    };
     Outputs::new().with_json("duties", &out)
 }
 
@@ -102,7 +106,11 @@ fn compile_patterns() -> Result<Vec<(&'static str, f32, Regex)>, ModuleError> {
         (MOD_OBLIGATION, 0.85, r"\bsind\s+verpflichtet\b"),
         (MOD_OBLIGATION, 0.80, r"\b(?:ist|sind)\s+anzuzeigen\b"),
         (MOD_OBLIGATION, 0.80, r"\baufzuzeichnen\b"),
-        (MOD_OBLIGATION, 0.80, r"\b(?:muss|müssen)\s+\w+\s+(?:eingehalten|gef[uü]hrt|gemeldet|nachgewiesen)\b"),
+        (
+            MOD_OBLIGATION,
+            0.80,
+            r"\b(?:muss|müssen)\s+\w+\s+(?:eingehalten|gef[uü]hrt|gemeldet|nachgewiesen)\b",
+        ),
         (MOD_PROHIBITION, 0.85, r"\bdarf\s+(?:nicht|kein)\b"),
         (MOD_PROHIBITION, 0.85, r"\bd[uü]rfen\s+(?:nicht|kein)\b"),
         (MOD_PROHIBITION, 0.85, r"\b(?:ist|sind)\s+untersagt\b"),
@@ -113,16 +121,15 @@ fn compile_patterns() -> Result<Vec<(&'static str, f32, Regex)>, ModuleError> {
     ];
     let mut out = Vec::with_capacity(raw.len());
     for (m, c, src) in raw {
-        let re = Regex::new(src).map_err(|e| {
+        let re = Regex::new(src)
-            ModuleError::invalid_input(format!("internal regex compile: {e}"))
+            .map_err(|e| ModuleError::invalid_input(format!("internal regex compile: {e}")))?;
-        })?;
         out.push((m, c, re));
     }
     Ok(out)
 }
 
 fn split_sentences(text: &str) -> Vec<&str> {
-    text.split_terminator(|c: char| c == '.' || c == ';' || c == '\n')
+    text.split_terminator(['.', ';', '\n'])
         .map(str::trim)
         .filter(|s| !s.is_empty() && s.len() > 4)
         .collect()
@@ -130,6 +137,7 @@ fn split_sentences(text: &str) -> Vec<&str> {
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
     use super::*;
 
     fn norm(paragraphs: Vec<(&str, &str)>) -> serde_json::Value {
@@ -169,7 +177,10 @@ mod tests {
         } else {
             duties.iter().map(|d| d.confidence).sum::<f32>() / duties.len() as f32
         };
-        Output { duties, avg_confidence: avg }
+        Output {
+            duties,
+            avg_confidence: avg,
+        }
     }
 
     #[test]
@@ -193,7 +204,10 @@ mod tests {
 
     #[test]
     fn no_duty_means_zero_avg() {
-        let result = extract(norm(vec![("(1)", "Dieser Satz enthält nichts Deontisches.")]));
+        let result = extract(norm(vec![(
+            "(1)",
+            "Dieser Satz enthält nichts Deontisches.",
+        )]));
         assert_eq!(result.duties.len(), 0);
         assert_eq!(result.avg_confidence, 0.0);
     }