perf(iconv): UTF-8 -> DBCS encode fast path — 2.6-3.7x, now beats glibc

UTF-8 -> DBCS legacy (Shift-JIS / Big5 / GBK / EUC-* / GB2312 / GB18030 / Johab)
encode still ran the generic UTF-8-source path: decode one char, then encode_one
+ encode_char (~100-arm dispatch) per char, plus outer-loop re-entry that
re-checks every preceding fast-path gate. Even with the O(1) direct-table
encoders (6750bb6), this measured 2.5-3.7x SLOWER than glibc (Shift-JIS 2.51x,
Big5 3.65x). The decode side (DBCS -> UTF-8) already had a tight loop; the encode
side did not.

Add a tight UTF-8 -> DBCS loop: decode each char inline (utf8_decode_step) then
call the per-codec encoder directly, skipping encode_char + encode_one and the
outer-loop re-entry. Byte-for-byte isomorphic: same decode + the same encode_*
the dispatch would pick; a decode error, unrepresentable char, or short room
breaks to the generic body for the exact EILSEQ/EINVAL/E2BIG ordering.

UTF-8->DBCS encode (ns/B, self / vs glibc):
  SHIFT_JIS  3.73 -> 1.46 = 2.56x  (2.51x -> 0.95x, now FASTER)
  EUC-JP     5.41 -> 1.46 = 3.71x  (0.60x -> 0.15x)
  BIG5       3.77 -> 1.42 = 2.65x  (3.65x -> 0.88x, now FASTER)

Isomorphism: iconv_differential_fuzz (7 tests; iconv_cjk_differential_fuzz_vs_glibc
covers UTF-8<->all 9 DBCS byte + errno + inbytesleft), 0 divergences vs host
glibc. Completes the iconv DBCS encode direction (decode side was done).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: Dicklesworthstone

crates/frankenlibc-core/src/iconv/mod.rs

@@ -9971,6 +9971,67 @@ pub fn iconv(
         // the generic body, which reproduces the exact EILSEQ/EINVAL/E2BIG
         // ordering. Placed after the ASCII/sb_translation fast paths so their
         // SIMD bulk-copy still wins for ASCII-transparent pairs.
+        // Fast path: UTF-8 -> DBCS legacy codec. Decode each char inline, then
+        // call the (direct-table O(1)) per-codec encoder directly in a tight loop,
+        // skipping the per-char encode_char (~100-arm match) + encode_one wrapper
+        // AND the outer-loop re-entry (re-checking every preceding fast-path gate)
+        // the generic UTF-8-source path below pays. Byte-for-byte isomorphic: same
+        // utf8_decode_step + char::from_u32 decode and the same encode_* the
+        // encode_char dispatch would select; a decode error, an unrepresentable
+        // char, or insufficient room leaves in_pos/out_pos untouched and breaks to
+        // the generic body for the exact EILSEQ/EINVAL/E2BIG ordering.
+        if from_enc == Encoding::Utf8
+            && !cd.emit_bom
+            && matches!(
+                cd.to,
+                Encoding::Gb18030
+                    | Encoding::ShiftJis
+                    | Encoding::Big5
+                    | Encoding::Gbk
+                    | Encoding::EucJp
+                    | Encoding::EucKr
+                    | Encoding::Cp949
+                    | Encoding::Gb2312
+                    | Encoding::Johab
+            )
+        {
+            while in_pos < input.len() {
+                let b0 = input[in_pos];
+                let (wc, len) = if b0 < 0x80 {
+                    (u32::from(b0), 1usize)
+                } else {
+                    match crate::string::wchar::utf8_decode_step(&input[in_pos..]) {
+                        crate::string::wchar::Utf8Step::Char { wc, len } => (wc, len),
+                        _ => break,
+                    }
+                };
+                let Some(ch) = char::from_u32(wc) else {
+                    break;
+                };
+                let out = &mut outbuf[out_pos..];
+                let r = match cd.to {
+                    Encoding::Gb18030 => encode_gb18030(ch, out),
+                    Encoding::ShiftJis => encode_shiftjis(ch, out),
+                    Encoding::Big5 => encode_big5(ch, out),
+                    Encoding::Gbk => encode_gbk(ch, out),
+                    Encoding::EucJp => encode_eucjp(ch, out),
+                    Encoding::EucKr => encode_euckr(ch, out),
+                    Encoding::Cp949 => encode_cp949(ch, out),
+                    Encoding::Gb2312 => encode_gb2312(ch, out),
+                    Encoding::Johab => encode_johab(ch, out),
+                    _ => unreachable!(),
+                };
+                let Ok(w) = r else {
+                    break;
+                };
+                in_pos += len;
+                out_pos += w;
+            }
+            if in_pos >= input.len() {
+                break;
+            }
+        }
+
         if from_enc == Encoding::Utf8 && !cd.emit_bom {
             let b0 = input[in_pos];
             let decoded = if b0 < 0x80 {