docs: convert remaining {@link}/{@code} to Markdown Javadoc (Sonar S7474)

Final sweep of hand-written sources (162 tags across 43 files). Generated
proto records are left untouched (regenerated from CodeGen, not analyzed).
Javadoc resolves every reference (failOnError + failOnWarnings).

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

Author: dfa1

cli/src/main/java/io/github/dfa1/vortex/cli/tui/IoWorker.java

@@ -12,7 +12,7 @@
 /// opened the file. The TUI dispatches all such calls to this worker so the
 /// render loop on the main thread never crosses the arena's owning thread.
 ///
-/// {@link #pending()} drives the status-line counter; callers should check it
+/// [#pending()] drives the status-line counter; callers should check it
 /// when computing UI state.
 public final class IoWorker implements AutoCloseable {
 
@@ -40,8 +40,8 @@ public void submit(Runnable task) {
             return;
         }
         pending.incrementAndGet();
-        // Unbounded {@link LinkedBlockingQueue} never rejects on capacity; {@code add} is the
-        // right idiom (throws {@code IllegalStateException} on the impossible case) so we don't
+        // Unbounded [LinkedBlockingQueue] never rejects on capacity; `add` is the
+        // right idiom (throws `IllegalStateException` on the impossible case) so we don't
         // silently drop tasks if anyone ever swaps in a bounded queue.
         queue.add(() -> {
             try {

cli/src/test/java/io/github/dfa1/vortex/cli/FilterCommandTest.java

@@ -23,7 +23,7 @@ class FilterCommandTest {
 
     @BeforeEach
     void setUp() throws IOException {
-        // 3-row Vortex file with one I64 column {@code id} = [1, 2, 3].
+        // 3-row Vortex file with one I64 column `id` = [1, 2, 3].
         file = writeSmallVortex(tmp, "filter.vortex");
     }
 

cli/src/test/java/io/github/dfa1/vortex/cli/ImportCommandTest.java

@@ -31,7 +31,7 @@ void noArgs_returnsUsageError() {
 
         @Test
         void delimiterMissingValue_returnsUsageError() {
-            // Given / When — {@code --delimiter} at the tail with no value
+            // Given / When — `--delimiter` at the tail with no value
             CliTestSupport.Captured result = capture(() ->
                     ImportCommand.run(new String[]{"import", "--delimiter"}));
 
@@ -125,9 +125,9 @@ void csvWithCustomDelimiter_imports(@TempDir Path tmp) throws IOException {
                     ImportCommand.run(new String[]{"import", "--delimiter", "\t", csv.toString()}));
 
             // Then — without the explicit delimiter the import would treat the whole row as one
-            // column. Success here confirms the {@code --delimiter} flag plumbs through.
-            // Output filename: input is {@code data.tsv}, deriveOutputPath only strips
-            // {@code .csv}/{@code .parquet} suffixes, so the result is {@code data.tsv.vortex}.
+            // column. Success here confirms the `--delimiter` flag plumbs through.
+            // Output filename: input is `data.tsv`, deriveOutputPath only strips
+            // `.csv`/`.parquet` suffixes, so the result is `data.tsv.vortex`.
             assertThat(result.status()).isEqualTo(ExitStatus.OK);
             assertThat(tmp.resolve("data.tsv.vortex")).exists();
         }

cli/src/test/java/io/github/dfa1/vortex/cli/tui/term/KeyDecoderTest.java

@@ -124,8 +124,8 @@ void next_multiDigitTildeCode_handlesTwoDigits() throws IOException {
 
     @Test
     void next_ss3SequenceVariant_decodesArrows() throws IOException {
-        // Given — DEC keypad / VT100 application-cursor mode uses {@code ESC O A}
-        // instead of {@code ESC [ A}. KeyDecoder must accept both prefixes so the
+        // Given — DEC keypad / VT100 application-cursor mode uses `ESC O A`
+        // instead of `ESC [ A`. KeyDecoder must accept both prefixes so the
         // TUI works under tmux / screen / putty configurations that ship SS3.
         assertThat(KeyDecoder.next(bytes(0x1B, 'O', 'A'))).isEqualTo(Key.ArrowUp.INSTANCE);
         assertThat(KeyDecoder.next(bytes(0x1B, 'O', 'D'))).isEqualTo(Key.ArrowLeft.INSTANCE);
@@ -135,7 +135,7 @@ void next_ss3SequenceVariant_decodesArrows() throws IOException {
 
     @Test
     void next_unknownEscapePrefix_yieldsEscape() throws IOException {
-        // Given — {@code ESC X} (X is neither '[' nor 'O') is not a recognised
+        // Given — `ESC X` (X is neither '[' nor 'O') is not a recognised
         // CSI or SS3 sequence. Must return Escape rather than try to decode further.
         ByteArrayInputStream in = bytes(0x1B, 'X', 'A');
 
@@ -148,7 +148,7 @@ void next_unknownEscapePrefix_yieldsEscape() throws IOException {
 
     @Test
     void next_eofMidTildeSequence_returnsEof() throws IOException {
-        // Given — partial {@code ESC [ 5} with no trailing tilde / digit
+        // Given — partial `ESC [ 5` with no trailing tilde / digit
         ByteArrayInputStream in = bytes(0x1B, '[', '5');
 
         // When
@@ -160,7 +160,7 @@ void next_eofMidTildeSequence_returnsEof() throws IOException {
 
     @Test
     void next_tildeWithoutTrailingTildeChar_yieldsEscape() throws IOException {
-        // Given — {@code ESC [ 5 x}: digit followed by a non-tilde non-digit.
+        // Given — `ESC [ 5 x`: digit followed by a non-tilde non-digit.
         // The trailing character must be re-yielded by the next call, not lost.
         ByteArrayInputStream in = bytes(0x1B, '[', '5', 'x', 'y');
 
@@ -177,7 +177,7 @@ void next_tildeWithoutTrailingTildeChar_yieldsEscape() throws IOException {
     @Test
     void next_controlByte_returnsCharWithRawValue() throws IOException {
         // Given — Ctrl-C is 0x03, no special handling — surfaced as Char so the
-        // TUI's keymap can match it via {@code Key.Char(3)} if needed.
+        // TUI's keymap can match it via `Key.Char(3)` if needed.
         ByteArrayInputStream in = bytes(0x03);
 
         // When

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

@@ -61,13 +61,13 @@ public boolean isSigned() {
     ///
     /// Unlike `PType.values()[ordinal]`, this method validates the ordinal against the
     /// declared range and throws [VortexException] for crafted out-of-range values rather
-    /// than the JDK's {@link ArrayIndexOutOfBoundsException}. Use this at every decode site that
+    /// than the JDK's [ArrayIndexOutOfBoundsException]. Use this at every decode site that
     /// reads a ptype from untrusted metadata.
     ///
     /// @param ordinal the enum ordinal, typically taken from a Protobuf `ptype` field
-    /// @return the {@link PType} for the given ordinal
+    /// @return the [PType] for the given ordinal
     /// @throws VortexException if `ordinal` is negative or greater than the largest defined
-    ///                         {@link PType} ordinal
+    ///                         [PType] ordinal
     public static PType fromOrdinal(int ordinal) {
         PType[] all = values();
         if (ordinal < 0 || ordinal >= all.length) {

core/src/main/java/io/github/dfa1/vortex/encoding/TimeUnit.java

@@ -10,7 +10,7 @@ public enum TimeUnit {
     Milliseconds,
     /// Seconds — ordinal 3.
     Seconds,
-    /// Days — ordinal 4. Not sub-dividable; {@link #divisor()} throws for this value.
+    /// Days — ordinal 4. Not sub-dividable; [#divisor()] throws for this value.
     Days;
 
     /// Returns the `TimeUnit` for the given wire tag byte.

core/src/main/java/io/github/dfa1/vortex/proto/ProtoWriter.java

@@ -95,7 +95,7 @@ void writeEmbedded(byte[] encoded) {
     /// Returns a mark to pass back to [#endLenDelim(int)]; the caller writes the payload
     /// in between. Avoids the alloc/copy round-trip of writing into a temporary `ProtoWriter`.
     ///
-    /// Reserves the worst-case 5 bytes for a varint32 length; {@link #endLenDelim} backpatches
+    /// Reserves the worst-case 5 bytes for a varint32 length; [#endLenDelim] backpatches
     /// the actual length and shifts the payload left if a shorter varint suffices.
     int beginLenDelim() {
         ensure(MAX_LEN_VARINT);

jdbc/src/main/java/io/github/dfa1/vortex/jdbc/JdbcImporter.java

@@ -29,7 +29,7 @@
 ///
 /// The schema is derived from [ResultSetMetaData] — no type inference is needed.
 /// SQL NULL values are mapped to `0`, `0.0`, `false`, or `""` depending on column type.
-/// Use {@link JdbcImportOptions#withFetchSize} to control driver-side streaming for large tables.
+/// Use [JdbcImportOptions#withFetchSize] to control driver-side streaming for large tables.
 public final class JdbcImporter {
 
     private JdbcImporter() {

performance/src/main/java/io/github/dfa1/vortex/performance/ParquetVsVortexReadBenchmark.java

@@ -42,10 +42,10 @@
 ///
 /// Two Parquet variants:
 ///   - `parquetRead` / `parquetReadMultiColumn`: batch column API
-///     ({@link ColumnReader#nextBatch()} + {@link ColumnReader#getDoubles()}) —
+///     ([ColumnReader#nextBatch()] + [ColumnReader#getDoubles()]) —
 ///     apples-to-apples comparison with Vortex's batch fold.
 ///   - `parquetReadRowByRow` / `parquetReadMultiColumnRowByRow`:
-///     Hardwood row cursor ({@link RowReader}) — measures row-oriented API overhead
+///     Hardwood row cursor ([RowReader]) — measures row-oriented API overhead
 ///     on top of format decode cost.
 ///
 /// Override the Parquet source with: `-Dbench.parquet=/path/to/file.parquet`

performance/src/main/java/io/github/dfa1/vortex/performance/RustVsJavaFilterBenchmark.java

@@ -42,7 +42,7 @@
 /// with a `close > threshold` predicate at varying selectivity.
 ///
 /// Phase 0 instrument for ADR 0010 (lazy decode). The threshold is chosen at
-/// setup time so each {@link #selectivity} value selects approximately that
+/// setup time so each [#selectivity] value selects approximately that
 /// fraction of rows. Both readers report the sum of surviving close values so
 /// the JVM cannot elide the per-row work.
 ///
@@ -52,7 +52,7 @@
 ///
 /// Requires a pre-existing OHLC file:
 /// `-Dvortex.bench.ohlc=/path/to/file.vtx`. Generate one by running
-/// {@link RustVsJavaReadBenchmark} first with the same `vortex.bench.ohlc`
+/// [RustVsJavaReadBenchmark] first with the same `vortex.bench.ohlc`
 /// pointing at the path you want (the read benchmark will write it lazily if
 /// the file does not exist yet).
 @State(Scope.Benchmark)
@@ -74,7 +74,7 @@ public class RustVsJavaFilterBenchmark {
     }
 
     /// Target fraction of rows that should satisfy `close > threshold`.
-    /// The threshold is computed in {@link #setup()} from a sample of the
+    /// The threshold is computed in [#setup()] from a sample of the
     /// "close" column; the realised selectivity is reported in the setup log
     /// and may differ slightly from this value on small samples.
     @Param({"0.001", "0.01", "0.1", "1.0"})