fix: address review comments — safety, endianness, docs

- Remove unused peek2() (replaced by peek_u16)
- peek_u16: use u16::from_le() to ensure correct byte order on all targets
- parse_number_unchecked: change from pub to private fn (only called
  internally when inplace=true with padded reader)
- parse_key_scalar: update doc to clarify it accepts multi-byte UTF-8,
  not just ASCII
- swar.rs: add compile_error for big-endian targets

Author: liuq19

sonic-number/src/swar.rs

@@ -2,7 +2,11 @@
 ///
 /// Based on simdjson's `parse_eight_digits_unrolled` technique.
 /// Uses pure u64 arithmetic to process 8 ASCII digits at a time.
-/// Works on all little-endian architectures without actual SIMD instructions.
+/// Requires little-endian byte order — the u64 load must place the first
+/// string byte in the least-significant byte position.
+
+#[cfg(target_endian = "big")]
+compile_error!("SWAR digit parsing requires little-endian byte order");
 
 /// Check if 8 consecutive bytes are all ASCII digits ('0'-'9').
 #[inline(always)]

src/parser.rs

@@ -309,9 +309,9 @@ where
     }
 
     /// Unchecked number parsing — requires padded buffer (PaddedSliceRead).
-    /// Uses the full padded buffer (including padding) so unchecked access is safe.
+    /// Only called internally when inplace=true (padded reader with ≥64 bytes padding).
     #[inline(always)]
-    pub fn parse_number_unchecked(&mut self, first: u8) -> Result<ParserNumber> {
+    fn parse_number_unchecked(&mut self, first: u8) -> Result<ParserNumber> {
         let reader = &mut self.read;
         let neg = first == b'-';
         let mut now = reader.index() - (!neg as usize);
@@ -347,8 +347,10 @@ where
         }
     }
 
-    /// Scalar key parsing for object keys — avoids SIMD setup overhead for short keys.
-    /// Simple while loop, let LLVM optimize the unrolling.
+    /// Fast path for keys that terminate within 24 bytes and contain no escapes (`\\`)
+    /// or control characters (`< 0x20`). Accepts any valid UTF-8 bytes (including
+    /// multi-byte sequences). Falls back to `parse_string_visit` on escape, control
+    /// byte, or if no closing `"` is found within 24 bytes.
     ///
     /// # Safety
     /// Only called when strbuf=None (padded reader path). PaddedSliceRead has 64 bytes

src/reader.rs

@@ -55,20 +55,13 @@ pub trait Reader<'de>: Sealed {
         self.as_u8_slice()
     }
 
-    /// Peek next 2 bytes as a fixed-size array reference. No bounds check needed
-    /// on padded readers (PaddedSliceRead always has ≥64 bytes of padding).
-    #[inline(always)]
-    fn peek2(&self) -> &[u8; 2] {
-        unsafe { &*(self.peek_n(2).unwrap_unchecked().as_ptr() as *const [u8; 2]) }
-    }
-
     /// Peek next 2 bytes as a little-endian u16 for single-instruction matching.
     /// E.g., `peek_u16() == u16::from_le_bytes([b',', b'"'])` matches `,"` in one cmp.
     /// Returns 0 if fewer than 2 bytes remain (0 won't match any structural char).
     #[inline(always)]
     fn peek_u16(&self) -> u16 {
         match self.peek_n(2) {
-            Some(s) => unsafe { (s.as_ptr() as *const u16).read_unaligned() },
+            Some(s) => u16::from_le(unsafe { (s.as_ptr() as *const u16).read_unaligned() }),
             None => 0,
         }
     }