Add functions to retrieve C* column names (#71)

Provide a way to retrieve C* column names from a query result

### Motivation:

- The underlying DataStax C++ driver already exposes column names via
cass_result_column_name()
- The Swift library already supports accessing columns by name via
row.column(_ name: String)
- However, there's no way to discover what column names are available in
a result set
- This is essential for building dynamic query tools, debug utilities,
or any application that needs to work with unknown schemas at compile
time

### Modifications:

2 new functions:

- columnName(at index: Int) -> String? - Returns the column name for a
given column index
- columnNames() -> [String] - Returns an array of all column names in
the result set

### Result:

Use case example:

```
let rows = try await session.query("SELECT * FROM system_schema.tables", on: eventLoop)
let columnNames = rows.columnNames()  // ["keyspace_name", "table_name", "id", ...]

for row in rows {
    for (index, columnName) in columnNames.enumerated() {
        if let column = row.column(index) {
            print("\(columnName): \(column.string ?? "<null>")")
        }
    }
}
```

Author: Samsv77

Sources/CassandraClient/Data.swift

@@ -44,6 +44,36 @@ extension CassandraClient {
             cass_result_column_count(self.rawPointer)
         }
 
+        /// Get column name by index
+        /// - Parameter index: The column index (0-based)
+        /// - Returns: The column name
+        /// - Throws: CassandraClient.Error if index is out of bounds or column name cannot be retrieved
+        public func columnName(at index: Int) throws -> String {
+            guard index >= 0 && index < self.columnsCount else {
+                throw CassandraClient.Error(CASS_ERROR_LIB_INDEX_OUT_OF_BOUNDS)
+            }
+
+            var namePtr: UnsafePointer<CChar>?
+            var nameLength: Int = 0
+
+            let result = cass_result_column_name(self.rawPointer, index, &namePtr, &nameLength)
+            guard result == CASS_OK, let name = namePtr else {
+                throw CassandraClient.Error(result)
+            }
+
+            let nameBuffer = UnsafeBufferPointer(start: name, count: nameLength)
+            return nameBuffer.withMemoryRebound(to: UInt8.self) {
+                String(decoding: $0, as: UTF8.self)
+            }
+        }
+
+        /// Get all column names
+        /// - Returns: Array of column names
+        /// - Throws: CassandraClient.Error if any column name cannot be retrieved
+        public func columnNames() throws -> [String] {
+            try (0..<self.columnsCount).map { try columnName(at: $0) }
+        }
+
         public func makeIterator() -> Iterator {
             Iterator(rows: self)
         }

Tests/CassandraClientTests/CassandraClientTests.swift

@@ -1118,6 +1118,84 @@ final class Tests: XCTestCase {
         }
     }
 
+    func testColumnName() throws {
+        let tableName = "test_\(DispatchTime.now().uptimeNanoseconds)"
+        try self.cassandraClient.run(
+            "create table \(tableName) (id int primary key, name text, age int, email text);"
+        ).wait()
+
+        try self.cassandraClient.run(
+            "insert into \(tableName) (id, name, age, email) values (1, 'Alice', 30, 'alice@example.com');"
+        ).wait()
+
+        let rows = try self.cassandraClient.query("select id, name, age, email from \(tableName);").wait()
+        XCTAssertEqual(rows.count, 1, "expected exactly one row")
+
+        // Test valid column indices
+        XCTAssertEqual(try rows.columnName(at: 0), "id", "first column should be 'id'")
+        XCTAssertEqual(try rows.columnName(at: 1), "name", "second column should be 'name'")
+        XCTAssertEqual(try rows.columnName(at: 2), "age", "third column should be 'age'")
+        XCTAssertEqual(try rows.columnName(at: 3), "email", "fourth column should be 'email'")
+
+        // Test invalid indices - should throw errors
+        XCTAssertThrowsError(try rows.columnName(at: -1), "negative index should throw error")
+        XCTAssertThrowsError(try rows.columnName(at: 4), "out of bounds index should throw error")
+        XCTAssertThrowsError(try rows.columnName(at: 100), "large out of bounds index should throw error")
+
+        // Test with select *
+        let rowsStar = try self.cassandraClient.query("select * from \(tableName);").wait()
+        XCTAssertNoThrow(try rowsStar.columnName(at: 0), "select * should return valid column names")
+        XCTAssertEqual(rowsStar.columnsCount, 4, "select * should return all 4 columns")
+    }
+
+    func testColumnNames() throws {
+        let tableName = "test_\(DispatchTime.now().uptimeNanoseconds)"
+        try self.cassandraClient.run(
+            "create table \(tableName) (id int primary key, username text, score bigint, active boolean);"
+        ).wait()
+
+        try self.cassandraClient.run(
+            "insert into \(tableName) (id, username, score, active) values (1, 'Bob', 9500, true);"
+        ).wait()
+
+        // Test columnNames with explicit column selection
+        let rows = try self.cassandraClient.query("select id, username, score, active from \(tableName);").wait()
+        let columnNames = try rows.columnNames()
+
+        XCTAssertEqual(columnNames.count, 4, "should return 4 column names")
+        XCTAssertEqual(columnNames[0], "id", "first column name should be 'id'")
+        XCTAssertEqual(columnNames[1], "username", "second column name should be 'username'")
+        XCTAssertEqual(columnNames[2], "score", "third column name should be 'score'")
+        XCTAssertEqual(columnNames[3], "active", "fourth column name should be 'active'")
+
+        // Test columnNames with select *
+        let rowsStar = try self.cassandraClient.query("select * from \(tableName);").wait()
+        let columnNamesStar = try rowsStar.columnNames()
+        XCTAssertEqual(columnNamesStar.count, 4, "select * should return all 4 column names")
+
+        // Verify column names array matches individual columnName calls
+        for (index, name) in columnNames.enumerated() {
+            XCTAssertEqual(
+                try rows.columnName(at: index),
+                name,
+                "columnNames array should match columnName at index \(index)"
+            )
+        }
+
+        // Test columnNames with partial column selection
+        let rowsPartial = try self.cassandraClient.query("select username, active from \(tableName);").wait()
+        let columnNamesPartial = try rowsPartial.columnNames()
+        XCTAssertEqual(columnNamesPartial.count, 2, "partial select should return 2 column names")
+        XCTAssertEqual(columnNamesPartial[0], "username", "first column should be 'username'")
+        XCTAssertEqual(columnNamesPartial[1], "active", "second column should be 'active'")
+
+        // Test columnNames with single column
+        let rowsSingle = try self.cassandraClient.query("select id from \(tableName);").wait()
+        let columnNamesSingle = try rowsSingle.columnNames()
+        XCTAssertEqual(columnNamesSingle.count, 1, "single column select should return 1 column name")
+        XCTAssertEqual(columnNamesSingle[0], "id", "single column should be 'id'")
+    }
+
     func testErrorMapping() {
         XCTAssertThrowsError(try self.cassandraClient.run("boom!").wait()) { error in
             XCTAssertEqual(