chore(ci): fix fmt, clippy, doc, test failures from Q2 PR

- fmt: rustfmt across new/modified files (test helpers, generator
  bin, ConstraintMode wiring).
- clippy:
  - Convert `impl Default for <Strategy>` blocks to
    `#[derive(Default)]` + `#[default]` per-variant for all eight
    type-mapping strategy enums and ConstraintMode (clippy
    `derivable_impls`).
  - Replace literal U+200B chars in `format_constraints_doc`'s
    pattern escaping with the `\u{200B}` Rust escape (clippy
    `invisible_characters`).
- doc: wrap `Vec<u8>` in backticks in the SchemaType::Primitive
  docstring (rustdoc `invalid_html_tags` treated `<u8>` as an
  unclosed HTML tag).
- test: add `serde_with: ..` to a SchemaType::Primitive pattern
  match in `examples/number_formats.rs`, and add the new `types`
  field to the GeneratorConfig literal in `examples/complete_workflow.rs`.

No behavior change. All four gates pass locally.

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

Author: lightsofapollo

.beads/issues.jsonl

@@ -313,6 +313,7 @@ fn demonstrate_rust_api(
         schema_extensions: vec![],
         enable_registry: false,
         registry_only: false,
+        types: openapi_to_rust::TypeMappingConfig::default(),
     };
 
     // Generate code

examples/complete_workflow.rs

@@ -83,8 +83,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                 openapi_to_rust::analysis::SchemaType::Object { properties, .. } => {
                     let mut prop_types = Vec::new();
                     for (prop_name, prop_info) in properties {
-                        if let openapi_to_rust::analysis::SchemaType::Primitive { rust_type } =
-                            &prop_info.schema_type
+                        if let openapi_to_rust::analysis::SchemaType::Primitive {
+                            rust_type, ..
+                        } = &prop_info.schema_type
                         {
                             prop_types.push(format!("{prop_name}: {rust_type}"));
                         } else {

examples/number_formats.rs

@@ -120,7 +120,7 @@ pub enum SchemaType {
     /// Simple primitive type. `serde_with` carries an optional
     /// `#[serde(with = "<path>")]` codec hint produced by the
     /// TypeMapper for typed scalars (e.g. `format: byte` →
-    /// Vec<u8> + `base64_serde`); the generator wraps this in a
+    /// `Vec<u8>` + `base64_serde`); the generator wraps this in a
     /// field-level `with = ...` attribute.
     Primitive {
         rust_type: String,
@@ -1020,9 +1020,7 @@ impl SchemaAnalyzer {
                 SchemaType::ExtensibleEnum { known_values } => known_values.len(),
                 _ => continue,
             };
-            if let Some(ext) =
-                extract_enum_extensions(&analyzed.original, enum_value_count, name)
-            {
+            if let Some(ext) = extract_enum_extensions(&analyzed.original, enum_value_count, name) {
                 analysis.enum_extensions.insert(name.clone(), ext);
             }
         }
@@ -1650,9 +1648,7 @@ impl SchemaAnalyzer {
                                 description: prop_description,
                                 default: prop_default,
                                 serde_attrs: Vec::new(),
-                                constraints: PropertyConstraints::from_schema_details(
-                                    prop_details,
-                                ),
+                                constraints: PropertyConstraints::from_schema_details(prop_details),
                             },
                         );
                         continue;
@@ -1763,9 +1759,7 @@ impl SchemaAnalyzer {
             Some(crate::openapi::AdditionalProperties::Boolean(false)) => {
                 ObjectAdditionalProperties::Forbidden
             }
-            Some(crate::openapi::AdditionalProperties::Schema(value_schema))
-                if typed_enabled =>
-            {
+            Some(crate::openapi::AdditionalProperties::Schema(value_schema)) if typed_enabled => {
                 let analyzed =
                     self.analyze_property_schema_with_context(value_schema, None, dependencies)?;
                 ObjectAdditionalProperties::Typed {
@@ -3777,8 +3771,7 @@ impl SchemaAnalyzer {
                         .unwrap_or(true);
 
                     if primitive_unions {
-                        let mapped =
-                            self.type_mapper.map(schema_type.clone(), schema.details());
+                        let mapped = self.type_mapper.map(schema_type.clone(), schema.details());
                         variants.push(SchemaRef {
                             target: mapped.rust_type,
                             nullable: false,
@@ -3817,8 +3810,8 @@ impl SchemaAnalyzer {
                             _ => format!("{context_name}Variant{inline_index}"),
                         };
 
-                        let rust_type = self
-                            .openapi_type_to_rust_type(schema_type.clone(), schema.details());
+                        let rust_type =
+                            self.openapi_type_to_rust_type(schema_type.clone(), schema.details());
 
                         self.resolved_cache.insert(
                             inline_type_name.clone(),

src/analysis.rs

@@ -77,8 +77,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             // for bisecting regressions caused by typed-scalar
             // adoption without editing the TOML config.
             if types_conservative {
-                generator_config.types =
-                    openapi_to_rust::TypeMappingConfig::conservative();
+                generator_config.types = openapi_to_rust::TypeMappingConfig::conservative();
             }
 
             println!(
@@ -132,8 +131,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             // TypeMapper from the user's [generator.types] config so
             // per-format strategies drive type generation (Q2.0).
             println!("🔍 Analyzing schemas...");
-            let type_mapper =
-                openapi_to_rust::TypeMapper::new(generator_config.types.clone());
+            let type_mapper = openapi_to_rust::TypeMapper::new(generator_config.types.clone());
             let mut analyzer = if generator_config.schema_extensions.is_empty() {
                 SchemaAnalyzer::with_type_mapper(spec_value, type_mapper)?
             } else {

src/bin/openapi-to-rust.rs

@@ -63,7 +63,11 @@ fn format_constraints_doc(c: &crate::analysis::PropertyConstraints) -> String {
         parts.push("uniqueItems=true".to_string());
     }
     if let Some(p) = &c.pattern {
-        let safe = p.replace("///", "/​//").replace("*/", "*​/");
+        // Insert a zero-width-space inside `///` and `*/` so they
+        // can't terminate the surrounding doc/block comment. Using
+        // the `\u{200B}` escape (vs. a literal U+200B) keeps clippy's
+        // `invisible_characters` lint happy.
+        let safe = p.replace("///", "/\u{200B}//").replace("*/", "*\u{200B}/");
         parts.push(format!("pattern=`{safe}`"));
     }
 
@@ -768,9 +772,7 @@ impl CodeGenerator {
         // Skipped silently when the set is empty so we don't litter
         // the output dir for specs whose generated types only use
         // std/serde/serde_json.
-        if let Some(toml) =
-            crate::type_mapping::render_required_deps_toml(&result.required_deps)
-        {
+        if let Some(toml) = crate::type_mapping::render_required_deps_toml(&result.required_deps) {
             let deps_path = self.config.output_dir.join("REQUIRED_DEPS.toml");
             fs::write(&deps_path, toml)?;
         }
@@ -1128,31 +1130,32 @@ impl CodeGenerator {
             })
             .collect();
 
-        let variants = variant_pairs.iter().map(
-            |(variant_ident, value, is_default, description)| {
-                let doc = description
-                    .as_ref()
-                    .map(|d| {
-                        let s = self.sanitize_doc_comment(d);
-                        quote! { #[doc = #s] }
-                    })
-                    .unwrap_or_default();
-                if *is_default {
-                    quote! {
-                        #doc
-                        #[default]
-                        #[serde(rename = #value)]
-                        #variant_ident,
-                    }
-                } else {
-                    quote! {
-                        #doc
-                        #[serde(rename = #value)]
-                        #variant_ident,
+        let variants =
+            variant_pairs
+                .iter()
+                .map(|(variant_ident, value, is_default, description)| {
+                    let doc = description
+                        .as_ref()
+                        .map(|d| {
+                            let s = self.sanitize_doc_comment(d);
+                            quote! { #[doc = #s] }
+                        })
+                        .unwrap_or_default();
+                    if *is_default {
+                        quote! {
+                            #doc
+                            #[default]
+                            #[serde(rename = #value)]
+                            #variant_ident,
+                        }
+                    } else {
+                        quote! {
+                            #doc
+                            #[serde(rename = #value)]
+                            #variant_ident,
+                        }
                     }
-                }
-            },
-        );
+                });
 
         // T13/T10: emit `as_str` and `Display` so the enum can be embedded in
         // query strings, headers, and path segments without requiring callers