perf(lambda-rs-args): Prune candidates shorter than the best levenshtein distance (#193)

## Summary

Improve unknown-argument suggestion performance in `lambda-rs-args` by
pruning candidates that cannot beat the current best Levenshtein
distance based on character-length lower bounds.

## Related Issues

N/A

## Changes

- Added an early-prune in `unknown_with_suggestion` to skip Levenshtein
calls when `abs(len(key) - len(arg)) >= best_distance`.
- Kept suggestion output behavior unchanged (`did you mean ...`).
- Added stress coverage with many unrelated flags to validate suggestion
quality under larger candidate sets.

## Type of Change

- [ ] Bug fix (non-breaking change that fixes an issue)
- [ ] Feature (non-breaking change that adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation (updates to docs, specs, tutorials, or comments)
- [x] Refactor (code change that neither fixes a bug nor adds a feature)
- [x] Performance (change that improves performance)
- [x] Test (adding or updating tests)
- [ ] Build/CI (changes to build process or CI configuration)

## Affected Crates

- [ ] `lambda-rs`
- [ ] `lambda-rs-platform`
- [x] `lambda-rs-args`
- [ ] `lambda-rs-logging`
- [ ] Other:

## Checklist

- [ ] Code follows the repository style guidelines (`cargo +nightly fmt
--all`)
- [ ] Code passes clippy (`cargo clippy --workspace --all-targets -- -D
warnings`)
- [ ] Tests pass (`cargo test --workspace`)
- [x] New code includes appropriate documentation
- [ ] Public API changes are documented
- [ ] Breaking changes are noted in this PR description

## Testing

**Commands run:**

```bash
cargo test -p lambda-rs-args
```

**Manual verification steps (if applicable):**

1. Trigger parse with an unknown flag similar to a known one (e.g.
`--portt` vs `--port`) and verify suggestion output remains correct.

## Screenshots/Recordings

N/A

## Platform Testing

- [x] macOS
- [ ] Windows
- [ ] Linux

## Additional Notes

Asymptotics: worst-case remains `O(A * L^2)` for `A` candidate args and
`L` string length, but the prune reduces expensive Levenshtein
evaluations from `O(A)` to `O(K)` in common cases (`K <= A`) where many
candidates are length-mismatched.

Author: vmarcella

crates/lambda-rs-args/src/lib.rs

@@ -1307,6 +1307,28 @@ mod tests {
     }
   }
 
+  #[test]
+  fn unknown_argument_suggests_with_many_unrelated_keys() {
+    let mut parser = ArgumentParser::new("app")
+      .with_argument(Argument::new("--port").with_type(ArgumentType::Integer));
+    for i in 0..500 {
+      let long_name = Box::leak(
+        format!("--very-long-unrelated-argument-name-{}", i).into_boxed_str(),
+      );
+      parser = parser.with_argument(
+        Argument::new(long_name).with_type(ArgumentType::String),
+      );
+    }
+
+    let err = parser.parse(&argv(&["--portt", "1"])).unwrap_err();
+    match err {
+      ArgsError::UnknownArgument(msg) => {
+        assert!(msg.contains("did you mean '--port'"))
+      }
+      _ => panic!(),
+    }
+  }
+
   #[test]
   fn missing_value_error() {
     let parser = ArgumentParser::new("app")
@@ -1512,7 +1534,16 @@ fn read_config_file(
 
 fn unknown_with_suggestion(arg: &str, parser: &ArgumentParser) -> String {
   let mut best: Option<(usize, String)> = None;
+  let arg_len = arg.chars().count();
   for key in parser.args.keys() {
+    // Levenshtein distance has a hard lower bound of the character-length gap.
+    // If that bound cannot beat the current best score, skip this candidate.
+    if let Some((best_distance, _)) = best.as_ref() {
+      let key_len = key.chars().count();
+      if key_len.abs_diff(arg_len) >= *best_distance {
+        continue;
+      }
+    }
     let d = levenshtein(arg, key);
     if best.as_ref().map(|(bd, _)| d < *bd).unwrap_or(true) {
       best = Some((d, key.clone()));