refactor: use peekByte for non-destructive null checking

Update unpackNull to peek at header byte before consuming, enabling
non-destructive type checking. Simplifies optional handling in unpackAny
by eliminating error-based control flow. Removes unused isNullError helper.

Author: lalinsky

src/any.zig

@@ -5,7 +5,6 @@ const NonOptional = @import("utils.zig").NonOptional;
 
 const packNull = @import("null.zig").packNull;
 const unpackNull = @import("null.zig").unpackNull;
-const isNullError = @import("null.zig").isNullError;
 
 const getBoolSize = @import("bool.zig").getBoolSize;
 const packBool = @import("bool.zig").packBool;
@@ -142,12 +141,10 @@ pub fn unpackAny(reader: *std.Io.Reader, allocator: std.mem.Allocator, comptime
             }
         },
         .optional => |opt_info| {
-            return unpackAny(reader, allocator, opt_info.child) catch |err| {
-                if (isNullError(err)) {
-                    return null;
-                }
-                return err;
+            unpackNull(reader) catch {
+                return try unpackAny(reader, allocator, opt_info.child);
             };
+            return null;
         },
         else => {},
     }

src/null.zig

@@ -13,8 +13,12 @@ pub fn packNull(writer: *std.Io.Writer) !void {
 }
 
 pub fn unpackNull(reader: *std.Io.Reader) !void {
-    const header = try reader.takeByte();
-    _ = try maybeUnpackNull(header, ?void);
+    const header = try reader.peekByte();
+    if (header == hdrs.NIL) {
+        reader.toss(1);
+        return;
+    }
+    return error.InvalidFormat;
 }
 
 pub fn maybePackNull(writer: *std.Io.Writer, comptime T: type, value: T) !?NonOptional(T) {
@@ -29,10 +33,6 @@ pub fn maybePackNull(writer: *std.Io.Writer, comptime T: type, value: T) !?NonOp
     return value;
 }
 
-pub fn isNullError(err: anyerror) bool {
-    return err == error.Null;
-}
-
 pub fn maybeUnpackNull(header: u8, comptime T: type) !T {
     switch (header) {
         hdrs.NIL => return if (isOptional(T)) null else error.Null,