fix(table): validate modified-UTF-8 continuation bytes in split decoder

read_java_utf now rejects lead bytes whose 2-/3-byte forms are not
followed by proper 10xxxxxx continuation bytes, matching the sibling
decoder in pk_vector_source. The legitimate 0xC0 0x80 encoding of NUL
still decodes to '\0'. Also add Split.deserialize to the Python stub.

Author: JunRuiLee

crates/paimon/src/table/source.rs

@@ -1010,15 +1010,23 @@ fn read_java_utf(cur: &mut &[u8]) -> crate::Result<String> {
     while i < bytes.len() {
         let b = bytes[i];
         let (unit, adv) = if b & 0x80 == 0 {
+            // 1-byte: 0xxxxxxx (includes raw 0x00)
             (b as u16, 1)
         } else if b & 0xE0 == 0xC0 {
-            let b2 = *bytes.get(i + 1).ok_or_else(utf_err)?;
-            ((((b & 0x1F) as u16) << 6) | (b2 & 0x3F) as u16, 2)
+            // 2-byte: 110xxxxx 10xxxxxx (0xC0 0x80 is Java's encoding of '\0')
+            if i + 1 >= bytes.len() || bytes[i + 1] & 0xC0 != 0x80 {
+                return Err(utf_err());
+            }
+            ((((b & 0x1F) as u16) << 6) | (bytes[i + 1] & 0x3F) as u16, 2)
         } else if b & 0xF0 == 0xE0 {
-            let b2 = *bytes.get(i + 1).ok_or_else(utf_err)?;
-            let b3 = *bytes.get(i + 2).ok_or_else(utf_err)?;
+            // 3-byte: 1110xxxx 10xxxxxx 10xxxxxx
+            if i + 2 >= bytes.len() || bytes[i + 1] & 0xC0 != 0x80 || bytes[i + 2] & 0xC0 != 0x80 {
+                return Err(utf_err());
+            }
             (
-                (((b & 0x0F) as u16) << 12) | (((b2 & 0x3F) as u16) << 6) | (b3 & 0x3F) as u16,
+                (((b & 0x0F) as u16) << 12)
+                    | (((bytes[i + 1] & 0x3F) as u16) << 6)
+                    | (bytes[i + 2] & 0x3F) as u16,
                 3,
             )
         } else {
@@ -1687,6 +1695,15 @@ mod tests {
         assert!(read_java_utf(&mut cur).is_err());
     }
 
+    #[test]
+    fn java_utf_rejects_malformed_continuation() {
+        // len=2, lead 0xC0 (2-byte form) followed by 0x41 ('A'), which is NOT a
+        // 10xxxxxx continuation byte. Must error, not silently decode to "\u{1}".
+        let bytes = [0x00u8, 0x02, 0xC0, 0x41];
+        let mut cur = bytes.as_slice();
+        assert!(read_java_utf(&mut cur).is_err());
+    }
+
     #[test]
     fn deletion_list_round_trips() {
         for list in [