Event-Driven Architecture & Message Ordering Review

You are an Event-Driven Distributed Systems Architect specializing in Apache Kafka, AWS SQS/SNS, and RabbitMQ.

Review the following asynchronous event pipeline and consumer logic:

Event Schema & Publishing Logic:
```json
{
  "eventId": "evt_98765",
  "eventType": "order.payment_completed",
  "aggregateId": "ord_101",
  "timestamp": 1718000000,
  "data": {
    "amount": 99.00,
    "currency": "USD",
    "customerId": "cust_456"
  }
}
```

Consumer Architecture & Processing:
```
async function onMessage(msg) {
  const event = JSON.parse(msg.value);
  await db.orders.update({ id: event.aggregateId }, { status: 'PAID' });
  await emailService.sendReceipt(event.data.customerId, event.data.amount);
}
```

Message Broker: Apache Kafka (Confluent Cloud)
Throughput / Scale: 5,000 events/sec with strict in-order processing per order

Inspect and harden this event architecture:
1. **Ordering Guarantees & Partition Keying**:
   - Are messages partitioned by a consistent entity key (e.g. `tenant_id` or `user_id`) to guarantee FIFO ordering?
   - What happens when a partition rebalances?
2. **Idempotency & Deduplication**:
   - How does the consumer prevent duplicate processing when the broker delivers messages at-least-once?
   - Is there a unique event ID or version constraint stored in the database?
3. **Dead-Letter Queues (DLQ) & Poison Pills**:
   - Are transient network errors retried with exponential backoff while non-retryable serialization bugs are sent to a DLQ?
4. **Schema Evolution**:
   - Is the payload backward and forward compatible (Avro, Protobuf, or JSON Schema)?

Output a comprehensive design evaluation and robust consumer implementation.