feat(core): DType static factories + asNullable() shortcut (ADR 0009 part 1)

Add static factory methods on DType (i8/i16/i32/i64, u8/u16/u32/u64,
f16/f32/f64, bool_, utf8, binary, null_, variant, decimal) returning
non-nullable instances, plus an asNullable() default method as fluent
sugar over withNullable(true).

```java
// before
new DType.Primitive(PType.I64, false)
new DType.Utf8(true)

// after
DType.i64()
DType.utf8().asNullable()
```

Why asNullable() and not nullable(): nullable() already exists as the
boolean accessor on every record (DType.Primitive::nullable returns boolean).
Adding a same-named default method on the interface clashed with the
record component getters. asNullable() reads as a fluent adjective without
shadowing the accessor.

Pure additive — records, withNullable, pattern matching, proto
serialization, and every existing call site are unchanged. ADR 0009
remains Proposed; parts 2 (structBuilder), 3 (typed Chunk), 4
(MemorySegment overload) follow separately.

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

Author: dfa1

core/src/main/java/io/github/dfa1/vortex/core/DType.java

@@ -22,6 +22,15 @@ public sealed interface DType
     /// @return {@code true} if null values are permitted
     boolean nullable();
 
+    /// Returns a copy of this type marked nullable. Sugar over
+    /// {@link #withNullable(boolean)} so call sites read as a fluent adjective:
+    /// {@code DType.i64().asNullable()}.
+    ///
+    /// @return a new {@link DType} identical to this one but with {@code nullable = true}
+    default DType asNullable() {
+        return withNullable(true);
+    }
+
     /// Returns a copy of this type with the given nullability.
     ///
     /// @param nullable the desired nullability for the returned type
@@ -42,6 +51,101 @@ default DType withNullable(boolean nullable) {
         };
     }
 
+    // ── Static factories ────────────────────────────────────────────────────
+    //
+    // Convenience entry points returning non-nullable instances. Combine with
+    // [#nullable()] for nullable columns. The underlying records are unchanged
+    // and remain usable directly (pattern matching, proto serialization, tests).
+
+    /// @return non-nullable {@link Bool}
+    static Bool bool_() {
+        return new Bool(false);
+    }
+
+    /// @return non-nullable {@link Utf8}
+    static Utf8 utf8() {
+        return new Utf8(false);
+    }
+
+    /// @return non-nullable {@link Binary}
+    static Binary binary() {
+        return new Binary(false);
+    }
+
+    /// @return non-nullable {@link Null}
+    static Null null_() {
+        return new Null(false);
+    }
+
+    /// @return non-nullable {@link Variant}
+    static Variant variant() {
+        return new Variant(false);
+    }
+
+    /// @return non-nullable {@link Primitive} of {@link PType#I8}
+    static Primitive i8() {
+        return new Primitive(PType.I8, false);
+    }
+
+    /// @return non-nullable {@link Primitive} of {@link PType#I16}
+    static Primitive i16() {
+        return new Primitive(PType.I16, false);
+    }
+
+    /// @return non-nullable {@link Primitive} of {@link PType#I32}
+    static Primitive i32() {
+        return new Primitive(PType.I32, false);
+    }
+
+    /// @return non-nullable {@link Primitive} of {@link PType#I64}
+    static Primitive i64() {
+        return new Primitive(PType.I64, false);
+    }
+
+    /// @return non-nullable {@link Primitive} of {@link PType#U8}
+    static Primitive u8() {
+        return new Primitive(PType.U8, false);
+    }
+
+    /// @return non-nullable {@link Primitive} of {@link PType#U16}
+    static Primitive u16() {
+        return new Primitive(PType.U16, false);
+    }
+
+    /// @return non-nullable {@link Primitive} of {@link PType#U32}
+    static Primitive u32() {
+        return new Primitive(PType.U32, false);
+    }
+
+    /// @return non-nullable {@link Primitive} of {@link PType#U64}
+    static Primitive u64() {
+        return new Primitive(PType.U64, false);
+    }
+
+    /// @return non-nullable {@link Primitive} of {@link PType#F16}
+    static Primitive f16() {
+        return new Primitive(PType.F16, false);
+    }
+
+    /// @return non-nullable {@link Primitive} of {@link PType#F32}
+    static Primitive f32() {
+        return new Primitive(PType.F32, false);
+    }
+
+    /// @return non-nullable {@link Primitive} of {@link PType#F64}
+    static Primitive f64() {
+        return new Primitive(PType.F64, false);
+    }
+
+    /// @param precision total number of significant decimal digits
+    /// @param scale     number of digits to the right of the decimal point
+    /// @return non-nullable {@link Decimal}
+    static Decimal decimal(int precision, int scale) {
+        return new Decimal((byte) precision, (byte) scale, false);
+    }
+
+    // ── Records ─────────────────────────────────────────────────────────────
+
     /// The SQL {@code NULL} type — no values, always nullable.
     ///
     /// @param nullable whether null values are permitted

core/src/test/java/io/github/dfa1/vortex/core/DTypeFactoriesTest.java

@@ -0,0 +1,83 @@
+package io.github.dfa1.vortex.core;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/// Static factories + {@code nullable()} shortcut (ADR 0009 part 1).
+class DTypeFactoriesTest {
+
+    @Test
+    void primitiveFactories_areNonNullable() {
+        // Given / When
+        DType.Primitive sut = DType.i64();
+
+        // Then
+        assertThat(sut.ptype()).isEqualTo(PType.I64);
+        assertThat(sut.nullable()).isFalse();
+    }
+
+    @Test
+    void nullableShortcut_marksType_nullable() {
+        // Given
+        DType sut = DType.utf8();
+
+        // When
+        DType marked = sut.asNullable();
+
+        // Then
+        assertThat(marked).isInstanceOf(DType.Utf8.class);
+        assertThat(marked.nullable()).isTrue();
+        // Original instance must remain non-nullable
+        assertThat(sut.nullable()).isFalse();
+    }
+
+    @Test
+    void allPrimitiveFactories_returnExpectedPType() {
+        // Given / When / Then
+        assertThat(DType.i8().ptype()).isEqualTo(PType.I8);
+        assertThat(DType.i16().ptype()).isEqualTo(PType.I16);
+        assertThat(DType.i32().ptype()).isEqualTo(PType.I32);
+        assertThat(DType.i64().ptype()).isEqualTo(PType.I64);
+        assertThat(DType.u8().ptype()).isEqualTo(PType.U8);
+        assertThat(DType.u16().ptype()).isEqualTo(PType.U16);
+        assertThat(DType.u32().ptype()).isEqualTo(PType.U32);
+        assertThat(DType.u64().ptype()).isEqualTo(PType.U64);
+        assertThat(DType.f16().ptype()).isEqualTo(PType.F16);
+        assertThat(DType.f32().ptype()).isEqualTo(PType.F32);
+        assertThat(DType.f64().ptype()).isEqualTo(PType.F64);
+    }
+
+    @Test
+    void bool_utf8_binary_null_variant_factories_areNonNullable() {
+        // Given / When / Then
+        assertThat(DType.bool_().nullable()).isFalse();
+        assertThat(DType.utf8().nullable()).isFalse();
+        assertThat(DType.binary().nullable()).isFalse();
+        assertThat(DType.null_().nullable()).isFalse();
+        assertThat(DType.variant().nullable()).isFalse();
+    }
+
+    @Test
+    void decimalFactory_setsPrecisionAndScale() {
+        // Given / When
+        DType.Decimal sut = DType.decimal(12, 4);
+
+        // Then
+        assertThat(sut.precision()).isEqualTo((byte) 12);
+        assertThat(sut.scale()).isEqualTo((byte) 4);
+        assertThat(sut.nullable()).isFalse();
+    }
+
+    @Test
+    void nullableShortcut_equivalentTo_withNullableTrue() {
+        // Given
+        DType direct = DType.f64().withNullable(true);
+
+        // When
+        DType viaShortcut = DType.f64().asNullable();
+
+        // Then
+        assertThat(viaShortcut).isEqualTo(direct);
+    }
+}