refactor: trim docstrings and prune redundant ResultSet-shape tests

Three small follow-ups from PR #175 review:

- StreamingResultSet.of: drop the paragraph that pointed at the
  HyperTypeToArrow.JDBC_TYPE_NAME_METADATA_KEY field-metadata key. The
  docstring spilled implementation detail of the metadata-stamping path
  into a generic "create a result set from a reader" entry-point; the
  type-name override is documented at HyperTypeToArrow / ColumnMetadata
  where it's relevant.

- ArrowStreamReaderCursor.loadNextNonEmptyBatch: rewrite the rationale
  to answer "why does the cursor consume empty batches instead of the
  caller?" directly. Empty IPC batches are valid Arrow and producers
  emit them; JDBC's next() only knows rows, so this cursor is the seam
  that translates batch-level signals into row-level advances.

- MetadataResultSetsTest: drop the JDBC ResultSet-shape slice (next /
  isClosed / getStatement / unwrap / isWrapperFor / getHoldability /
  getFetchSize / setFetchSize / getWarnings / getConcurrency / getType
  / getFetchDirection). Those test the StreamingResultSet plumbing
  shared by every result set on this branch and are already covered by
  StreamingResultSetMethodTest. Keep the arity-contract slice
  (short/long/right/null/empty rows) — that is the
  metadata-result-set-specific behavior.

Addresses: review comments on PR #175.

Author: mkaufmann

jdbc-core/src/main/java/com/salesforce/datacloud/jdbc/core/StreamingResultSet.java

@@ -87,10 +87,6 @@ public static StreamingResultSet of(ArrowStreamReader reader, BufferAllocator al
      * buffer accounting clears before the allocator's budget check. Callers must not close
      * either separately.
      *
-     * <p>The column metadata (including any {@link ColumnMetadata#getTypeName()} override
-     * stamped under {@link com.salesforce.datacloud.jdbc.protocol.data.HyperTypeToArrow#JDBC_TYPE_NAME_METADATA_KEY})
-     * is derived from the Arrow schema via {@link ArrowToHyperTypeMapper#toColumnMetadata(org.apache.arrow.vector.types.pojo.Field)}.
-     *
      * @param reader The Arrow stream, owned by the result set.
      * @param allocator The allocator backing the reader, owned by the result set.
      * @param queryId The query identifier.

jdbc-core/src/test/java/com/salesforce/datacloud/jdbc/core/metadata/MetadataResultSetsTest.java

@@ -6,32 +6,21 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import com.salesforce.datacloud.jdbc.core.MetadataSchemas;
 import com.salesforce.datacloud.jdbc.protocol.data.ColumnMetadata;
 import com.salesforce.datacloud.jdbc.protocol.data.HyperType;
-import java.sql.ResultSet;
-import java.sql.ResultSetMetaData;
-import java.sql.SQLException;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
-import lombok.SneakyThrows;
 import lombok.val;
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
 /**
- * Tests for {@link MetadataResultSets}. Two slices:
- * <ul>
- *   <li><b>Arity contract</b> — rows must match the schema column count; null rows are allowed
- *       as the all-nulls shape (matching the legacy {@code coerceRows} convention).
- *   <li><b>JDBC ResultSet shape</b> — empty metadata result sets expose the standard JDBC shape
- *       (row=0, closeable, forward-only, holdability, etc.).
- * </ul>
+ * Tests the {@link MetadataResultSets#of} arity contract: rows must match the schema column
+ * count; null rows are allowed as the all-nulls shape (matching the legacy {@code coerceRows}
+ * convention). Generic JDBC {@link java.sql.ResultSet} shape (closeable, forward-only,
+ * holdability, etc.) is exercised by {@code StreamingResultSetMethodTest} since metadata
+ * result sets share the {@link com.salesforce.datacloud.jdbc.core.StreamingResultSet} plumbing.
  */
 class MetadataResultSetsTest {
 
@@ -40,8 +29,6 @@ class MetadataResultSetsTest {
             new ColumnMetadata("b", HyperType.int32(true)),
             new ColumnMetadata("c", HyperType.bool(true)));
 
-    // --- Arity contract ---
-
     @Test
     void shortRowRejected() {
         val rows = Collections.singletonList(Arrays.<Object>asList("only-one"));
@@ -88,89 +75,4 @@ void emptyRowsAccepted() throws Exception {
             assertThat(rs.next()).isFalse();
         }
     }
-
-    // --- JDBC ResultSet shape on an empty metadata result set ---
-
-    private ResultSet emptyMetadataResultSet;
-
-    @BeforeEach
-    public void initEmptyMetadataResultSet() throws SQLException {
-        emptyMetadataResultSet = MetadataResultSets.empty(MetadataSchemas.COLUMNS);
-    }
-
-    @Test
-    void getRow() throws SQLException {
-        assertThat(emptyMetadataResultSet.getRow()).isEqualTo(0);
-
-        emptyMetadataResultSet.close();
-        assertThrows(SQLException.class, () -> emptyMetadataResultSet.next());
-    }
-
-    @Test
-    void next() throws SQLException {
-        emptyMetadataResultSet.close();
-        assertThrows(SQLException.class, () -> emptyMetadataResultSet.next());
-    }
-
-    @Test
-    void isClosed() throws SQLException {
-        assertFalse(emptyMetadataResultSet.isClosed());
-        emptyMetadataResultSet.close();
-        assertTrue(emptyMetadataResultSet.isClosed());
-    }
-
-    @Test
-    void getStatement() throws SQLException {
-        assertThat(emptyMetadataResultSet.getStatement()).isNull();
-    }
-
-    @Test
-    void unwrap() {
-        assertThrows(SQLException.class, () -> emptyMetadataResultSet.unwrap(ResultSetMetaData.class));
-    }
-
-    @Test
-    void isWrapperFor() throws SQLException {
-        // StreamingResultSet implements DataCloudResultSet / ResultSet; it is not a wrapper for
-        // arbitrary unrelated types.
-        assertThat(emptyMetadataResultSet.isWrapperFor(ResultSetMetaData.class)).isFalse();
-    }
-
-    @Test
-    void getHoldability() throws SQLException {
-        assertThat(emptyMetadataResultSet.getHoldability()).isEqualTo(ResultSet.HOLD_CURSORS_OVER_COMMIT);
-    }
-
-    @Test
-    void getFetchSize() throws SQLException {
-        assertThat(emptyMetadataResultSet.getFetchSize()).isEqualTo(0);
-    }
-
-    @Test
-    void setFetchSize() throws SQLException {
-        // StreamingResultSet controls its own fetch size and ignores caller-supplied hints.
-        emptyMetadataResultSet.setFetchSize(0);
-    }
-
-    @SneakyThrows
-    @Test
-    void getWarnings() {
-        assertThat((Iterable<? extends Throwable>) emptyMetadataResultSet.getWarnings())
-                .isNull();
-    }
-
-    @Test
-    void getConcurrency() throws SQLException {
-        assertThat(emptyMetadataResultSet.getConcurrency()).isEqualTo(ResultSet.CONCUR_READ_ONLY);
-    }
-
-    @Test
-    void getType() throws SQLException {
-        assertThat(emptyMetadataResultSet.getType()).isEqualTo(ResultSet.TYPE_FORWARD_ONLY);
-    }
-
-    @Test
-    void getFetchDirection() throws SQLException {
-        assertThat(emptyMetadataResultSet.getFetchDirection()).isEqualTo(ResultSet.FETCH_FORWARD);
-    }
 }