feat(picker2): complete Picker2 prototype

Picker2 replaces the original Picker1 with a two-phase (tag → pick) +
mask-bitmap architecture, decoupling argument matching from type
conversion via a composable matcher pipeline.

Architecture
- FlagMatcher — boolean flags (--verbose)
- ArgMatcher — single flag+value pairs (--name Alice)
- MultiArgMatcher — multi-value flag groups (--files a.txt b.txt)
- PositionalMatcher — positional arguments, respects `--`
- SingleMatcher — composite for Single-type Pickables

Types
- Flag (Active/Inactive) — semantic bool flag value
- String + 14 numeric types via SinglePickable trait
- Vec<T> — greedy multi-value (all SinglePickable types)
- VecUntil<T> — bounded multi-value via BoundaryCheck trait
- VecUntil<T>, pick_string, pick_numbers, pick_bool, pick_flag

Style system
- UNIX_STYLE (kebab), POWERSHELL_STYLE (Pascal), WINDOWS_STYLE (Pascal)
- naming_case auto-conversion via just_fmt integration
- Style-aware separator (= for Unix, : for PS/Windows)

Infrastructure
- internal_repeat! macro generates PickerPattern1..=32
- SinglePickable blanket impl → Pickable
- MultiPickableWithBoundary trait with greedy/bounded variants
- 151 integration tests
- Docs updated for parser feature

1 files changed, 225 insertions, 0 deletions

diff --git a/mingling_picker/src/parselib/style.rs b/mingling_picker/src/parselib/style.rs
new file mode 100644
index 0000000..4ea161f
--- /dev/null
+++ b/mingling_picker/src/parselib/style.rs
@@ -0,0 +1,225 @@
+use std::sync::OnceLock;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+use crate::parselib::ParserStyleNamingCase::{Kebab, Pascal};
+
+/// Defines the style of command-line argument parsing (prefixes, separators, etc.).
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub struct ParserStyle<'a> {
+    /// End-of-options marker (e.g., `--`)
+    pub end_of_options: &'a str,
+
+    /// Prefix for long options (e.g., `--` or `/`)
+    pub long_prefix: &'a str,
+
+    /// Prefix for short options (e.g., `-` or `/`)
+    pub short_prefix: &'a str,
+
+    /// Prefix for combined short flags (e.g., `-abc`)
+    pub combine_prefix: &'a str,
+
+    /// Separator between name and value (e.g., `=` or `:`)
+    pub value_separator: char,
+
+    /// Whether option names are case-sensitive
+    pub case_sensitive: bool,
+
+    /// Whether combining short flags is allowed (e.g., `-abc` for `-a -b -c`)
+    pub allow_combine: bool,
+
+    /// Naming case
+    pub naming_case: ParserStyleNamingCase,
+}
+
+impl<'a> ParserStyle<'a> {
+    /// Formats a flag (short or long) into a full command-line option string.
+    ///
+    /// This method takes any type that can be converted into a `FlagStr` and produces
+    /// a complete option string by prepending the appropriate prefix.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// use mingling_picker::parselib::{ParserStyle, FlagStr, UNIX_STYLE};
+    /// let style = &UNIX_STYLE;
+    ///
+    /// assert_eq!(style.flag_string('v'), "-v");
+    /// assert_eq!(style.flag_string("verbose"), "--verbose");
+    /// ```
+    ///
+    /// # Parameters
+    ///
+    /// * `flag` - A value that can be converted to `FlagStr`, either a `char` for short flags
+    ///   or a `&str` for long flags.
+    ///
+    /// # Returns
+    ///
+    /// A `String` with the prefix and the flag name combined.
+    #[must_use]
+    #[inline(always)]
+    pub fn flag_string<F>(&self, flag: F) -> String
+    where
+        F: Into<FlagStr<'a>>,
+    {
+        match flag.into() {
+            FlagStr::Short(short) => format!("{}{}", self.short_prefix, short),
+            FlagStr::Long(long) => format!("{}{}", self.long_prefix, long),
+        }
+    }
+}
+
+/// Represents a flag name for command-line argument parsing.
+///
+/// This enum can hold either a short flag (a single character, e.g., `'v'` for `-v`)
+/// or a long flag (a string, e.g., `"verbose"` for `--verbose`).
+///
+/// # Examples
+///
+/// ```
+/// use mingling_picker::parselib::FlagStr;
+///
+/// let short: FlagStr = 'v'.into();
+/// let long: FlagStr = "verbose".into();
+/// ```
+pub enum FlagStr<'a> {
+    /// A short flag represented by a single character.
+    Short(char),
+    /// A long flag represented by a string slice.
+    Long(&'a str),
+}
+
+impl<'a> From<char> for FlagStr<'a> {
+    /// Converts a single character into a `FlagStr::Short`.
+    fn from(c: char) -> Self {
+        FlagStr::Short(c)
+    }
+}
+
+impl<'a> From<&'a str> for FlagStr<'a> {
+    /// Converts a string slice into a `FlagStr::Long`.
+    fn from(s: &'a str) -> Self {
+        FlagStr::Long(s)
+    }
+}
+
+impl<'a> From<&'a String> for FlagStr<'a> {
+    /// Converts a reference to a `String` into a `FlagStr::Long`.
+    fn from(s: &'a String) -> Self {
+        FlagStr::Long(s.as_str())
+    }
+}
+
+#[repr(u8)]
+#[derive(Default, Clone, Copy, PartialEq, Eq)]
+pub enum ParserStyleNamingCase {
+    /// snake_case format (e.g., `brew_coffee`)
+    #[default]
+    Snake,
+    /// camelCase format (e.g., `brewCoffee`)
+    Camel,
+    /// PascalCase format (e.g., `BrewCoffee`)
+    Pascal,
+    /// kebab-case format (e.g., `brew-coffee`)
+    Kebab,
+    /// dot.case format (e.g., `brew.coffee`)
+    Dot,
+    /// Title Case format (e.g., `Brew Coffee`)
+    Title,
+    /// lower case format (e.g., `brew coffee`)
+    Lower,
+    /// UPPER CASE format (e.g., `BREW COFFEE`)
+    Upper,
+}
+
+impl ParserStyleNamingCase {
+    /// Converts the input string `s` to the naming case represented by this variant.
+    ///
+    /// This method takes any type `S` that can be converted into a `String` and
+    /// produced from a `String`, applies the corresponding case transformation,
+    /// and returns the result.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use mingling_picker::parselib::ParserStyleNamingCase;
+    ///
+    /// let camel = ParserStyleNamingCase::Camel;
+    /// assert_eq!(camel.convert("brew_coffee".to_string()), "brewCoffee");
+    ///
+    /// let kebab = ParserStyleNamingCase::Kebab;
+    /// assert_eq!(kebab.convert("BrewCoffee".to_string()), "brew-coffee");
+    /// ```
+    pub fn convert<S>(&self, s: S) -> S
+    where
+        S: Into<String> + From<String>,
+    {
+        match self {
+            ParserStyleNamingCase::Camel => just_fmt::camel_case!(s.into()).into(),
+            ParserStyleNamingCase::Pascal => just_fmt::pascal_case!(s.into()).into(),
+            ParserStyleNamingCase::Kebab => just_fmt::kebab_case!(s.into()).into(),
+            ParserStyleNamingCase::Snake => just_fmt::snake_case!(s.into()).into(),
+            ParserStyleNamingCase::Dot => just_fmt::dot_case!(s.into()).into(),
+            ParserStyleNamingCase::Title => just_fmt::title_case!(s.into()).into(),
+            ParserStyleNamingCase::Lower => just_fmt::lower_case!(s.into()).into(),
+            ParserStyleNamingCase::Upper => just_fmt::upper_case!(s.into()).into(),
+        }
+    }
+}
+
+/// Unix-like style (e.g., `--verbose`, `-v`, `--name=value`)
+pub const UNIX_STYLE: ParserStyle = ParserStyle {
+    end_of_options: "--",
+    long_prefix: "--",
+    short_prefix: "-",
+    combine_prefix: "-",
+    value_separator: '=',
+    case_sensitive: true,
+    allow_combine: true,
+    naming_case: Kebab,
+};
+
+/// PowerShell style (e.g., `-Verbose`, `-Name:value`)
+pub const POWERSHELL_STYLE: ParserStyle = ParserStyle {
+    end_of_options: "--",
+    long_prefix: "-",
+    short_prefix: "-",
+    combine_prefix: "-",
+    value_separator: ':',
+    case_sensitive: false,
+    allow_combine: false,
+    naming_case: Pascal,
+};
+
+/// Windows-style command-line (e.g., `/Verbose`, `/Name:value`)
+pub const WINDOWS_STYLE: ParserStyle = ParserStyle {
+    end_of_options: "--",
+    long_prefix: "/",
+    short_prefix: "/",
+    combine_prefix: "/",
+    value_separator: ':',
+    case_sensitive: false,
+    allow_combine: false,
+    naming_case: Pascal,
+};
+
+static GLOBAL_STYLE: OnceLock<ParserStyle<'static>> = OnceLock::new();
+static GLOBAL_STYLE_SET: AtomicBool = AtomicBool::new(false);
+
+impl<'a> ParserStyle<'a> {
+    /// Sets the global parser style.
+    ///
+    /// This function can only be called once. Subsequent calls will have no effect.
+    /// The style is stored as a static reference; the provided style must be a static
+    /// constant (e.g., `&'static ParserStyle`). Use the built-in constants like
+    /// `UNIX_STYLE`, `POWERSHELL_STYLE`, or `WINDOWS_STYLE`.
+    pub fn set_global_style(style: &'static ParserStyle<'static>) {
+        if !GLOBAL_STYLE_SET.load(Ordering::Acquire) && GLOBAL_STYLE.set(*style).is_ok() {
+            GLOBAL_STYLE_SET.store(true, Ordering::Release);
+        }
+    }
+
+    /// Returns the global parser style, falling back to `UNIX_STYLE` if not set.
+    pub fn global_style() -> &'static ParserStyle<'static> {
+        GLOBAL_STYLE.get().unwrap_or(&UNIX_STYLE)
+    }
+}