perf!: remove CommentSettings and always strip all comment types (#80)

## Summary

This PR removes the `CommentSettings` struct and simplifies the API to
always strip all comment types, resulting in significant performance
improvements.

## Breaking Changes ⚠️

This is a **major breaking change** (requires v3.0.0):
- Removed `CommentSettings` struct from the public API
- Removed `StripComments::with_settings()` method  
- Functions no longer accept settings parameters
- The library now always strips all comment types and trailing commas

## Performance Improvements 🚀

Benchmark results show significant improvements:
- **tsconfig**: ~6% faster
- **no_comments**: ~7% faster
- **large_with_comments**: No regression

The optimizations come from:
- Eliminating 4-6 conditional checks per character
- Simpler control flow enabling better compiler optimizations
- Reduced branching in hot paths

## Changes

### Core Library
- Removed `CommentSettings` struct entirely
- Simplified all functions to remove settings parameters
- Optimized state transition functions by removing conditional checks
- Removed tests for selective comment stripping

### WASM Bindings
- Kept `CommentSettings` struct for backward compatibility
- Settings parameter is now ignored (always strips all comments)
- Added deprecation notices in documentation

## Migration Guide

### Before
```rust
use json_strip_comments::{strip_comments_in_place, CommentSettings};

let mut json = String::from(input);
strip_comments_in_place(&mut json, CommentSettings::default()).unwrap();
```

### After  
```rust
use json_strip_comments::strip_comments_in_place;

let mut json = String::from(input);
strip_comments_in_place(&mut json).unwrap();
```

## Rationale

The analysis showed that `CommentSettings::all()` (stripping all comment
types) is the default and most common use case. By removing the
flexibility of selective comment stripping, we can:
1. Simplify the API surface
2. Improve performance for the primary use case
3. Reduce code complexity and maintenance burden

🤖 Generated with [Claude Code](https://claude.ai/code)

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: Boshen

src/lib.rs

@@ -74,7 +74,6 @@ use State::{
 pub struct StripComments<T: Read> {
     inner: T,
     state: State,
-    settings: CommentSettings,
 }
 
 impl<T> StripComments<T>
@@ -85,19 +84,6 @@ where
         Self {
             inner: input,
             state: Top,
-            settings: CommentSettings::default(),
-        }
-    }
-
-    /// Create a new `StripComments` with settings which may be different from the default.
-    ///
-    /// This is useful if you wish to disable allowing certain kinds of comments.
-    #[inline]
-    pub fn with_settings(settings: CommentSettings, input: T) -> Self {
-        Self {
-            inner: input,
-            state: Top,
-            settings,
         }
     }
 }
@@ -109,7 +95,7 @@ where
     fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
         let count = self.inner.read(buf)?;
         if count > 0 {
-            strip_buf(&mut self.state, &mut buf[..count], self.settings)?;
+            strip_buf(&mut self.state, &mut buf[..count])?;
         } else if self.state != Top && self.state != InLineComment {
             return Err(ErrorKind::InvalidData.into());
         }
@@ -121,144 +107,43 @@ where
 ///
 /// /// ## Example
 /// ```
-/// use json_strip_comments::{strip_comments_in_place, CommentSettings};
+/// use json_strip_comments::strip_comments_in_place;
 ///
 /// let mut string = String::from(r#"{
 /// // c line comment
 /// "a": "comment in string /* a */"
 /// ## shell line comment
 /// } /** end */"#);
 ///
-/// strip_comments_in_place(&mut string, CommentSettings::default()).unwrap();
+/// strip_comments_in_place(&mut string).unwrap();
 ///
 /// assert_eq!(string, "{
 ///                  \n\"a\": \"comment in string /* a */\"
 ///                     \n}           ");
 ///
 /// ```
-pub fn strip_comments_in_place(s: &mut str, settings: CommentSettings) -> Result<()> {
+pub fn strip_comments_in_place(s: &mut str) -> Result<()> {
     // Safety: we have made sure the text is UTF-8
-    strip_buf(&mut Top, unsafe { s.as_bytes_mut() }, settings)
+    strip_buf(&mut Top, unsafe { s.as_bytes_mut() })
 }
 
 pub fn strip(s: &mut str) -> Result<()> {
-    strip_comments_in_place(s, CommentSettings::all())
+    strip_comments_in_place(s)
 }
 
-/// Settings for `StripComments`
-///
-/// The default is for all comment types to be enabled.
-#[derive(Copy, Clone, Debug)]
-pub struct CommentSettings {
-    /// True if c-style block comments (`/* ... */`) are removed.
-    pub block_comments: bool,
-    /// True if c-style `//` line comments are removed.
-    pub slash_line_comments: bool,
-    /// True if shell-style `#` line comments are removed.
-    pub hash_line_comments: bool,
-    /// True of trailing commas are removed.
-    pub trailing_commas: bool,
-}
-
-impl Default for CommentSettings {
-    fn default() -> Self {
-        Self::all()
-    }
-}
-
-impl CommentSettings {
-    /// Enable all comment Styles
-    pub const fn all() -> Self {
-        Self {
-            block_comments: true,
-            slash_line_comments: true,
-            hash_line_comments: true,
-            trailing_commas: true,
-        }
-    }
-    /// Only allow line comments starting with `#`
-    pub const fn hash_only() -> Self {
-        Self {
-            hash_line_comments: true,
-            block_comments: false,
-            slash_line_comments: false,
-            trailing_commas: false,
-        }
-    }
-    /// Only allow "c-style" comments.
-    ///
-    /// Specifically, line comments beginning with `//` and
-    /// block comment like `/* ... */`.
-    pub const fn c_style() -> Self {
-        Self {
-            block_comments: true,
-            slash_line_comments: true,
-            hash_line_comments: false,
-            trailing_commas: true,
-        }
-    }
-
-    /// Create a new `StripComments` for `input`, using these settings.
-    ///
-    /// Transform `input` into a [`Read`] that strips out comments.
-    /// The types of comments to support are determined by the configuration of
-    /// `self`.
-    ///
-    /// ## Examples
-    ///
-    /// ```
-    /// use json_strip_comments::CommentSettings;
-    /// use std::io::Read;
-    ///
-    /// let input = r#"{
-    /// // c line comment
-    /// "a": "b"
-    /// /** multi line
-    /// comment
-    /// */ }"#;
-    ///
-    /// let mut stripped = String::new();
-    /// CommentSettings::c_style().strip_comments(input.as_bytes()).read_to_string(&mut stripped).unwrap();
-    ///
-    /// assert_eq!(stripped, "{
-    ///                  \n\"a\": \"b\"
-    ///                           }");
-    /// ```
-    ///
-    /// ```
-    /// use json_strip_comments::CommentSettings;
-    /// use std::io::Read;
-    ///
-    /// let input = r#"{
-    /// ## shell line comment
-    /// "a": "b"
-    /// }"#;
-    ///
-    /// let mut stripped = String::new();
-    /// CommentSettings::hash_only().strip_comments(input.as_bytes()).read_to_string(&mut stripped).unwrap();
-    ///
-    /// assert_eq!(stripped, "{
-    ///                     \n\"a\": \"b\"\n}");
-    /// ```
-    #[inline]
-    pub fn strip_comments<I: Read>(self, input: I) -> StripComments<I> {
-        StripComments::with_settings(self, input)
-    }
-}
 
 fn consume_comment_whitespace_until_maybe_bracket(
     state: &mut State,
     buf: &mut [u8],
     i: &mut usize,
-    settings: CommentSettings,
 ) -> Result<bool> {
     *i += 1;
     let len = buf.len();
     while *i < len {
         let c = &mut buf[*i];
         *state = match state {
             Top => {
-                *state = top(c, settings);
+                *state = top(c);
                 if c.is_ascii_whitespace() {
                     *i += 1;
                     continue;
@@ -267,7 +152,7 @@ fn consume_comment_whitespace_until_maybe_bracket(
             }
             InString => in_string(*c),
             StringEscape => InString,
-            InComment => in_comment(c, settings)?,
+            InComment => in_comment(c)?,
             InBlockComment => consume_block_comments(buf, i),
             MaybeCommentEnd => maybe_comment_end(c),
             InLineComment => consume_line_comments(buf, i),
@@ -277,7 +162,7 @@ fn consume_comment_whitespace_until_maybe_bracket(
     Ok(false)
 }
 
-fn strip_buf(state: &mut State, buf: &mut [u8], settings: CommentSettings) -> Result<()> {
+fn strip_buf(state: &mut State, buf: &mut [u8]) -> Result<()> {
     let mut i = 0;
     let len = buf.len();
 
@@ -288,12 +173,10 @@ fn strip_buf(state: &mut State, buf: &mut [u8], settings: CommentSettings) -> Re
         match state {
             Top => {
                 let cur = i;
-                let new_state = top(c, settings);
-                if settings.trailing_commas
-                    && *c == b','
-                {
+                let new_state = top(c);
+                if *c == b',' {
                     let mut temp_state = new_state;
-                    if consume_comment_whitespace_until_maybe_bracket(&mut temp_state, buf, &mut i, settings)? {
+                    if consume_comment_whitespace_until_maybe_bracket(&mut temp_state, buf, &mut i)? {
                         buf[cur] = b' ';
                     }
                     *state = temp_state;
@@ -303,7 +186,7 @@ fn strip_buf(state: &mut State, buf: &mut [u8], settings: CommentSettings) -> Re
             }
             InString => *state = in_string(*c),
             StringEscape => *state = InString,
-            InComment => *state = in_comment(c, settings)?,
+            InComment => *state = in_comment(c)?,
             InBlockComment => *state = consume_block_comments(buf, &mut i),
             MaybeCommentEnd => *state = maybe_comment_end(c),
             InLineComment => *state = consume_line_comments(buf, &mut i),
@@ -353,16 +236,14 @@ fn consume_block_comments(buf: &mut [u8], i: &mut usize) -> State {
 }
 
 #[inline(always)]
-fn top(c: &mut u8, settings: CommentSettings) -> State {
+fn top(c: &mut u8) -> State {
     match *c {
         b'"' => InString,
         b'/' => {
-            if settings.block_comments || settings.slash_line_comments {
-                *c = b' ';
-            }
+            *c = b' ';
             InComment
         }
-        b'#' if settings.hash_line_comments => {
+        b'#' => {
             *c = b' ';
             InLineComment
         }
@@ -380,10 +261,10 @@ fn in_string(c: u8) -> State {
 }
 
 #[inline]
-fn in_comment(c: &mut u8, settings: CommentSettings) -> Result<State> {
+fn in_comment(c: &mut u8) -> Result<State> {
     let new_state = match *c {
-        b'*' if settings.block_comments => InBlockComment,
-        b'/' if settings.slash_line_comments => InLineComment,
+        b'*' => InBlockComment,
+        b'/' => InLineComment,
         _ => return Err(ErrorKind::InvalidData.into()),
     };
     *c = b' ';
@@ -489,71 +370,11 @@ mod tests {
         assert_eq!(err.kind(), ErrorKind::InvalidData);
     }
 
-    #[test]
-    fn no_hash_comments() {
-        let json = r#"# bad comment
-        {"a": "b"}"#;
-        let mut stripped = String::new();
-        CommentSettings::c_style()
-            .strip_comments(json.as_bytes())
-            .read_to_string(&mut stripped)
-            .unwrap();
-        assert_eq!(stripped, json);
-    }
-
-    #[test]
-    fn no_slash_line_comments() {
-        let json = r#"// bad comment
-        {"a": "b"}"#;
-        let mut stripped = String::new();
-        let err = CommentSettings::hash_only()
-            .strip_comments(json.as_bytes())
-            .read_to_string(&mut stripped)
-            .unwrap_err();
-        assert_eq!(err.kind(), ErrorKind::InvalidData);
-    }
-
-    #[test]
-    fn no_block_comments() {
-        let json = r#"/* bad comment */ {"a": "b"}"#;
-        let mut stripped = String::new();
-        let err = CommentSettings::hash_only()
-            .strip_comments(json.as_bytes())
-            .read_to_string(&mut stripped)
-            .unwrap_err();
-        assert_eq!(err.kind(), ErrorKind::InvalidData);
-    }
-
-    #[test]
-    fn keep_all() {
-        let original = String::from(
-            r#"
-     {
-         "name": /* full */ "John Doe",
-         "age": 43, # hash line comment
-         "phones": [
-             "+44 1234567", // work phone
-             "+44 2345678", // home phone
-         ], /** comment **/
-     }"#,
-        );
-        let mut changed = original.clone();
-        let _ = strip_comments_in_place(
-            &mut changed,
-            CommentSettings {
-                block_comments: false,
-                slash_line_comments: false,
-                hash_line_comments: false,
-                trailing_commas: false,
-            },
-        );
-        assert_eq!(original, changed);
-    }
 
     #[test]
     fn strip_in_place() {
         let mut json = String::from(r#"{/* Comment */"hi": /** abc */ "bye"}"#);
-        strip_comments_in_place(&mut json, CommentSettings::default()).unwrap();
+        strip_comments_in_place(&mut json).unwrap();
         assert_eq!(json, r#"{             "hi":            "bye"}"#);
     }
 
@@ -574,7 +395,7 @@ mod tests {
             # another
         }"#,
         );
-        strip_comments_in_place(&mut json, CommentSettings::default()).unwrap();
+        strip_comments_in_place(&mut json).unwrap();
 
         let expected = r#"{
             "a1": [1 ],