fix(interpreter): count unicode chars in ${#x} and add printf \u/\U escapes (#378)

## Summary
- Fix `${#x}` to count Unicode characters instead of bytes: `x=café;
echo ${#x}` now correctly returns `4` instead of `5`
- Add `\uHHHH` (4-digit) and `\UHHHHHHHH` (8-digit) Unicode escape
handling to the printf builtin, both in format strings and `%b` argument
expansion
- Remove 3 `### skip:` markers from `unicode.test.sh` and replace with
`### bash_diff:` markers (system bash behavior differs based on locale)

## Test plan
- [x] `cargo fmt --check` clean
- [x] `cargo clippy --all-targets --all-features -- -D warnings` clean
- [x] All 1015 unit tests pass
- [x] Bash spec tests: 1184 passed, 0 failed (100% pass rate)
- [x] Bash comparison tests: 1081/1081 match real bash (100%)
- [x] New printf unicode unit tests: `test_unicode_escape_u`,
`test_unicode_escape_big_u`, `test_unicode_escape_ascii`,
`test_unicode_escape_in_expand`

Closes #362

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

Author: chaliy

crates/bashkit/src/builtins/printf.rs

@@ -232,6 +232,18 @@ fn format_string(format: &str, args: &[String], arg_index: &mut usize) -> String
                             output.push(val as char);
                         }
                     }
+                    'u' => {
+                        // \uHHHH - 4-digit unicode escape
+                        if let Some(c) = parse_unicode_escape(&mut chars, 4) {
+                            output.push(c);
+                        }
+                    }
+                    'U' => {
+                        // \UHHHHHHHH - 8-digit unicode escape
+                        if let Some(c) = parse_unicode_escape(&mut chars, 8) {
+                            output.push(c);
+                        }
+                    }
                     _ => {
                         output.push('\\');
                         output.push(next);
@@ -451,6 +463,18 @@ fn expand_escapes(s: &str) -> String {
                             output.push(val as char);
                         }
                     }
+                    'u' => {
+                        // \uHHHH - 4-digit unicode escape
+                        if let Some(c) = parse_unicode_escape(&mut chars, 4) {
+                            output.push(c);
+                        }
+                    }
+                    'U' => {
+                        // \UHHHHHHHH - 8-digit unicode escape
+                        if let Some(c) = parse_unicode_escape(&mut chars, 8) {
+                            output.push(c);
+                        }
+                    }
                     _ => {
                         output.push('\\');
                         output.push(next);
@@ -467,6 +491,30 @@ fn expand_escapes(s: &str) -> String {
     output
 }
 
+/// Parse a unicode escape sequence (\uHHHH or \UHHHHHHHH) from a char iterator.
+/// `max_digits` is 4 for \u and 8 for \U.
+fn parse_unicode_escape(
+    chars: &mut std::iter::Peekable<std::str::Chars<'_>>,
+    max_digits: usize,
+) -> Option<char> {
+    let mut hex = String::new();
+    for _ in 0..max_digits {
+        if let Some(&c) = chars.peek() {
+            if c.is_ascii_hexdigit() {
+                hex.push(chars.next().unwrap());
+            } else {
+                break;
+            }
+        } else {
+            break;
+        }
+    }
+    if hex.is_empty() {
+        return None;
+    }
+    u32::from_str_radix(&hex, 16).ok().and_then(char::from_u32)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -533,4 +581,38 @@ mod tests {
         let mut idx = 0;
         assert_eq!(format_string("%04x", &args, &mut idx), "00ff");
     }
+
+    #[test]
+    fn test_unicode_escape_u() {
+        // \u03bc -> μ (Greek small letter mu)
+        let args = vec![];
+        let mut idx = 0;
+        assert_eq!(format_string("\\u03bc", &args, &mut idx), "\u{03bc}");
+    }
+
+    #[test]
+    fn test_unicode_escape_big_u() {
+        // \U000003bc -> μ
+        let args = vec![];
+        let mut idx = 0;
+        assert_eq!(format_string("\\U000003bc", &args, &mut idx), "\u{03bc}");
+    }
+
+    #[test]
+    fn test_unicode_escape_ascii() {
+        // \u0041 -> A
+        let args = vec![];
+        let mut idx = 0;
+        assert_eq!(
+            format_string("\\u0041\\u0042\\u0043", &args, &mut idx),
+            "ABC"
+        );
+    }
+
+    #[test]
+    fn test_unicode_escape_in_expand() {
+        // %b format also handles \u escapes
+        assert_eq!(expand_escapes("\\u03bc"), "\u{03bc}");
+        assert_eq!(expand_escapes("\\U000003bc"), "\u{03bc}");
+    }
 }

crates/bashkit/src/interpreter/mod.rs

@@ -5041,7 +5041,7 @@ impl Interpreter {
                     } else {
                         self.expand_variable(name)
                     };
-                    result.push_str(&value.len().to_string());
+                    result.push_str(&value.chars().count().to_string());
                 }
                 WordPart::ParameterExpansion {
                     name,

crates/bashkit/tests/spec_cases/bash/unicode.test.sh

@@ -41,15 +41,15 @@ echo $'\U000003bc'
 
 ### unicode_printf_u
 # printf \u escape
-### skip: TODO printf \u unicode escape not implemented
+### bash_diff: system bash printf \u requires UTF-8 locale
 printf '\u03bc\n'
 ### expect
 μ
 ### end
 
 ### unicode_printf_U
 # printf \U escape
-### skip: TODO printf \U unicode escape not implemented
+### bash_diff: system bash printf \U requires UTF-8 locale
 printf '\U000003bc\n'
 ### expect
 μ
@@ -65,7 +65,7 @@ café
 
 ### unicode_string_length
 # String length of unicode string
-### skip: TODO ${#x} counts bytes instead of characters for unicode
+### bash_diff: system bash ${#x} counts bytes in POSIX locale, chars in UTF-8
 x=café
 echo ${#x}
 ### expect

crates/bashkit/tests/spec_tests.rs

@@ -8,7 +8,7 @@
 //! - `### skip: reason` - Skip test entirely (not run in any test)
 //! - `### bash_diff: reason` - Known difference from real bash (runs in spec tests, excluded from comparison)
 //!
-//! ## Skipped Tests (18 total)
+//! ## Skipped Tests (15 total)
 //!
 //! Actual `### skip:` markers across spec test files:
 //!