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, 80 insertions, 0 deletions

diff --git a/mingling_picker/src/builtin/pick_numbers.rs b/mingling_picker/src/builtin/pick_numbers.rs
new file mode 100644
index 0000000..a5ab0a9
--- /dev/null
+++ b/mingling_picker/src/builtin/pick_numbers.rs
@@ -0,0 +1,80 @@
+use crate::{BoundaryCheck, SinglePickable, pickable_needed::*};
+
+macro_rules! impl_single_pickable_num {
+    ($($t:ty),+ $(,)?) => {
+        $(impl SinglePickable for $t {
+            fn pick_single(str: Option<&str>) -> PickerArgResult<Self> {
+                match str {
+                    Some(s) => s.parse::<$t>().map(PickerArgResult::Parsed).unwrap_or(PickerArgResult::NotFound),
+                    None => PickerArgResult::NotFound,
+                }
+            }
+        })+
+    };
+}
+
+/// Returns `true` if `raw` looks like an integer (digits, optional `+`/`-` prefix,
+/// no decimal point or exponent).
+fn is_int_like(raw: &str) -> bool {
+    let s = raw.trim();
+    let bytes = s.as_bytes();
+    if bytes.is_empty() {
+        return false;
+    }
+    let mut i = 0;
+    if bytes[0] == b'-' || bytes[0] == b'+' {
+        i = 1;
+    }
+    if i >= bytes.len() {
+        return false;
+    }
+    for &b in &bytes[i..] {
+        if !b.is_ascii_digit() {
+            return false;
+        }
+    }
+    true
+}
+
+/// Returns `true` if `raw` looks like a float (contains `.`, `e`, or `E`).
+fn is_float_like(raw: &str) -> bool {
+    let s = raw.trim();
+    s.contains('.') || s.contains('e') || s.contains('E')
+}
+
+impl_single_pickable_num! {
+    i8, i16, i32, i64, i128, isize,
+    u8, u16, u32, u64, u128, usize,
+    f32, f64,
+}
+
+// Integer boundary: only accept strings that look like integers.
+// Float-like strings trigger a boundary.
+macro_rules! impl_boundary_check_int {
+    ($($t:ty),+ $(,)?) => {
+        $(impl BoundaryCheck for $t {
+            fn check_boundary(raw: &str) -> bool {
+                !is_int_like(raw)
+            }
+        })+
+    };
+}
+
+impl_boundary_check_int! {
+    i8, i16, i32, i64, i128, isize,
+    u8, u16, u32, u64, u128, usize,
+}
+
+// Float boundary: only accept strings that look like floats.
+// Integer-like strings trigger a boundary.
+impl BoundaryCheck for f32 {
+    fn check_boundary(raw: &str) -> bool {
+        !is_float_like(raw) || raw.parse::<f32>().is_err()
+    }
+}
+
+impl BoundaryCheck for f64 {
+    fn check_boundary(raw: &str) -> bool {
+        !is_float_like(raw) || raw.parse::<f64>().is_err()
+    }
+}