feat: expose Zstd.versionNumber() (#16)

* refactor: make NativeCall.requireNative return void

Every caller uses it as a guard statement and discards the returned
segment, so the fluent return was dead. Drop it.

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

* feat: expose Zstd.versionNumber()

Wire up the previously-unused VERSION_NUMBER binding as a public
int Zstd.versionNumber() (MAJOR*10000 + MINOR*100 + PATCH, e.g. 10507
for 1.5.7), paralleling version() for programmatic version checks. Test
asserts it stays consistent with the version() string.

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

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: dfa1

zstd/src/main/java/io/github/dfa1/zstd/Zstd.java

@@ -227,6 +227,18 @@ public static String version() {
         }
     }
 
+    /// Runtime zstd version as a single number for programmatic comparison,
+    /// encoded `MAJOR * 10000 + MINOR * 100 + PATCH` — e.g. `10507` for `1.5.7`.
+    ///
+    /// @return the linked zstd library version number
+    public static int versionNumber() {
+        try {
+            return (int) Bindings.VERSION_NUMBER.invokeExact();
+        } catch (Throwable t) {
+            throw NativeCall.rethrow(t);
+        }
+    }
+
     // --- package-private helpers shared with the context classes ---
     // Native-call status checking and segment guards live in NativeCall.
 

zstd/src/test/java/io/github/dfa1/zstd/ZstdTest.java

@@ -135,5 +135,20 @@ void reportsSemanticVersion() {
             // When the runtime version is read / Then it is an x.y.z string
             assertThat(Zstd.version()).matches("\\d+\\.\\d+\\.\\d+");
         }
+
+        @Test
+        void reportsVersionNumberConsistentWithTheString() {
+            // Given the x.y.z version string split into its parts
+            String[] parts = Zstd.version().split("\\.");
+            int expected = Integer.parseInt(parts[0]) * 10000
+                    + Integer.parseInt(parts[1]) * 100
+                    + Integer.parseInt(parts[2]);
+
+            // When the numeric version is read
+            int number = Zstd.versionNumber();
+
+            // Then it encodes MAJOR * 10000 + MINOR * 100 + PATCH
+            assertThat(number).isEqualTo(expected);
+        }
     }
 }