Add key route affinity support for TransactWriteItemsRequest

Summary

TransactWriteItemsRequest is not currently supported by the key route affinity feature, but transactional writes are a primary use case for LWT (Lightweight Transaction) optimization.

Background

Key route affinity improves LWT performance by routing requests with the same partition key to the same coordinator node, reducing Paxos round-trips. DynamoDB transactions (TransactWriteItems) are implemented using LWT in Alternator, making them ideal candidates for this optimization.

Current Behavior

KeyAffinityRequestClassifier.shouldApply() returns false for TransactWriteItemsRequest, causing all transactional writes to use round-robin routing regardless of the affinity mode setting.

Proposed Solution

Add support for single-partition-key transactions:

1. Check if all items in the transaction target the same partition key
2. If yes, apply key route affinity
3. If no (multi-key transaction), fall back to round-robin

private static boolean shouldApplyTransactWriteItems(
    KeyRouteAffinity mode, TransactWriteItemsRequest request) {
  
  if (mode == KeyRouteAffinity.NONE) {
    return false;
  }
  
  // TransactWriteItems always uses LWT, so both RMW and ANY_WRITE should apply
  // But only if all items share the same partition key
  
  List<TransactWriteItem> items = request.transactItems();
  if (items == null || items.isEmpty()) {
    return false;
  }
  
  // Extract partition key from first item and verify all items match
  // Return true only if single-key transaction
  return isSinglePartitionKeyTransaction(items);
}

Considerations

• Multi-key transactions: Cannot be optimized since items may need different coordinators. These should continue using round-robin.
• Table name extraction: Need to handle Put, Update, Delete, and ConditionCheck within TransactWriteItem.
• Partition key extraction: Each operation type has different structure for accessing the key.

Files to Modify

• src/main/java/com/scylladb/alternator/keyrouting/KeyAffinityRequestClassifier.java
• src/test/java/com/scylladb/alternator/keyrouting/KeyAffinityRequestClassifierTest.java
• src/test/java/com/scylladb/alternator/KeyRouteAffinityClientTest.java

Acceptance Criteria

• Single-partition-key TransactWriteItemsRequest uses key route affinity
• Multi-partition-key transactions fall back to round-robin
• Unit tests cover both scenarios
• Integration test verifies transactional writes route correctly

Start in src/main/java/com/scylladb/alternator/keyrouting/KeyAffinityRequestClassifier.java and inspect shouldApply() plus the existing request-classification tests. Add coverage in KeyAffinityRequestClassifierTest.java for single- and multi-partition-key transactions, then use KeyRouteAffinityClientTest.java to verify transactional routing behavior. Done means single-key transactions use affinity and multi-key transactions retain round-robin routing.