refactor(reader): drop dead length < 0 blob check; reuse PTypeIO LE layouts

Two follow-ups:

- checkBlobBounds: drop the `length < 0` clause. Every caller passes a
  u32-masked PostscriptSegment.length() (`bb.getInt(..) & 0xFFFFFFFFL`), always
  >= 0, so the branch is unreachable — the equivalent mutant pitest flagged.
  Removing it takes the reader file-structure classes to a 100% mutation score
  (the only non-killed mutation is a depth-recursion timeout, which pitest
  counts as detected). The `offset < 0` check stays — offset is u64 and can read
  back negative.

- Tests: reuse the public PTypeIO.LE_INT / LE_SHORT layout constants instead of
  re-declaring them locally, and inline the single-use I32 dtype (no shared
  DType constant exists — it is duplicated per test file).

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

Author: dfa1

reader/src/main/java/io/github/dfa1/vortex/reader/PostscriptParser.java

@@ -90,10 +90,12 @@ static void validateSegmentSpecs(List<SegmentSpec> specs, long fileSize) {
     }
 
     private static void checkBlobBounds(String name, long offset, long length, long fileSize) {
-        // Same overflow-safe range form as IoBounds.checkRange (no redundant `offset > fileSize`
-        // clause: length >= 0 makes it implied by the final comparison). Keeps the blob-named
-        // message that checkRange's generic text would lose.
-        if (offset < 0 || length < 0 || length > fileSize - offset) {
+        // Overflow-safe containment in [0, fileSize], keeping the blob-named message that
+        // IoBounds.checkRange's generic text would lose. Two clauses checkRange carries are
+        // omitted because they are unreachable here: every caller passes a u32-masked
+        // PostscriptSegment.length() (always >= 0, so no `length < 0` check), which in turn makes
+        // an `offset > fileSize` check redundant — it is already implied by the final comparison.
+        if (offset < 0 || length > fileSize - offset) {
             throw new VortexException(
                     "postscript " + name + " blob out of bounds: offset=" + offset
                             + " length=" + length + " fileSize=" + fileSize);

reader/src/test/java/io/github/dfa1/vortex/reader/FlatSegmentDecoderDecodeTest.java

@@ -11,10 +11,9 @@
 
 import java.lang.foreign.Arena;
 import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import java.nio.ByteOrder;
 import java.util.List;
 
+import static io.github.dfa1.vortex.encoding.PTypeIO.LE_INT;
 import static org.assertj.core.api.Assertions.assertThat;
 
 /// Successful flat-segment decode path — complements [FlatSegmentBoundsSecurityTest] (which only
@@ -27,11 +26,6 @@
 ///   null node and the decode would not produce an `UnknownArray`.
 class FlatSegmentDecoderDecodeTest {
 
-    private static final ValueLayout.OfInt LE_INT =
-            ValueLayout.JAVA_INT_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN);
-
-    private static final DType DTYPE = new DType.Primitive(PType.I32, false);
-
     @Test
     void decode_unknownEncodingWithBufferPadding_returnsUnknownArray() {
         ReadRegistry registry = ReadRegistry.builder().allowUnknown().build();
@@ -49,7 +43,8 @@ void decode_unknownEncodingWithBufferPadding_returnsUnknownArray() {
             seg.set(LE_INT, padding + fb.length, fb.length);
 
             // When — encoding index 0 maps to an id no decoder handles
-            Array result = sut.decode(seg, List.of("vortex.nonexistent"), DTYPE, 0, arena);
+            Array result = sut.decode(seg, List.of("vortex.nonexistent"),
+                    new DType.Primitive(PType.I32, false), 0, arena);
 
             // Then — the allow-unknown path produced an UnknownArray (proves both the +padding
             // walk and the UnknownArrayNode fallback ran)

reader/src/test/java/io/github/dfa1/vortex/reader/TrailerLengthBoundaryTest.java

@@ -5,9 +5,8 @@
 import org.junit.jupiter.api.Test;
 
 import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import java.nio.ByteOrder;
 
+import static io.github.dfa1.vortex.encoding.PTypeIO.LE_SHORT;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
@@ -18,9 +17,6 @@
 /// exact-fill case — this pins that edge.
 class TrailerLengthBoundaryTest {
 
-    private static final ValueLayout.OfShort LE_SHORT =
-            ValueLayout.JAVA_SHORT_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN);
-
     /// Builds a well-formed 8-byte trailer (`version | postscriptLen | magic`) with the given
     /// postscript length, so only the length-vs-body check is under test.
     private static MemorySegment trailer(int postscriptLen) {