docs: update changeset and examples for in-batch deduplication

Update documentation to reflect the simplified deduplication feature
that only works within a single batch/queue cycle.

Changes:
- Rewrote changeset to describe in-batch deduplication only
- Removed cross-batch specific documentation
- Restored original useBatcher example (basic batching demo)
- Created new useBatcherInBatchDedup example with:
  - Interactive UI for testing in-batch deduplication
  - Activity log showing adds vs. duplicates
  - Visual feedback for deduplication behavior
- Deleted old useBatcherDedup example

The feature is now simpler and more focused: it prevents duplicates
within the same batch but does not track across batch cycles.

Author: restareaByWeezy

.changeset/add-deduplication-feature.md

@@ -1,57 +1,44 @@
 ---
-'@tanstack/pacer': minor
+"@tanstack/pacer": minor
 ---
 
-Add cross-batch/cross-execution deduplication support to Batcher and Queuer
+Add in-batch/in-queue deduplication support to Batcher and Queuer
 
-This feature extends the existing `deduplicateItems` option to track processed items across batch/execution cycles. When enabled, items that have already been processed will be automatically skipped.
+This feature adds `deduplicateItems` option to prevent duplicate items within the same batch or queue.
 
-### Enhanced Options
+### New Options
 
-- `deduplicateItems: boolean` - Now prevents duplicates **both within and across batches** (default: false)
-- `deduplicateStrategy: 'keep-first' | 'keep-last'` - Only affects in-batch duplicates (default: 'keep-first')
-- `getItemKey: (item) => string | number` - Extract unique key from item
-- `maxTrackedKeys: number` - Maximum keys to track with FIFO eviction (default: 1000)
-- `onDuplicate: (newItem, existingItem?, instance) => void` - Called for both in-batch and cross-batch duplicates
-
-### New Methods
-
-- `hasProcessedKey(key)` - Check if a key has been processed
-- `peekProcessedKeys()` - Get a copy of all processed keys
-- `clearProcessedKeys()` - Clear the processed keys history
-
-### New State Properties
-
-- `processedKeys: Array<string | number>` - Keys that have been processed (similar to RateLimiter's executionTimes)
+- `deduplicateItems: boolean` - Enable automatic deduplication within the current batch/queue (default: false)
+- `deduplicateStrategy: 'keep-first' | 'keep-last'` - Strategy for handling duplicates (default: 'keep-first')
+- `getItemKey: (item) => string | number` - Extract unique key from item (defaults to JSON.stringify for objects)
 
 ### Behavior
 
 When `deduplicateItems` is enabled:
+- **'keep-first'**: Ignores new items if an item with the same key already exists in the batch/queue
+- **'keep-last'**: Replaces existing items with new items that have the same key
 
-1. **In-batch duplicates**: Merged based on `deduplicateStrategy` ('keep-first' or 'keep-last')
-2. **Cross-batch duplicates**: Skipped entirely (already processed)
-3. `onDuplicate` called with `existingItem` for in-batch, `undefined` for cross-batch
-
-### Use Case
-
-Prevents redundant processing when the same data is requested multiple times:
-
-- API calls: Don't fetch user-123 if it was already fetched
-- No-code tools: Multiple components requesting the same resource
-- Event processing: Skip events that have already been handled
-
-Similar to request deduplication in TanStack Query, but at the batching/queuing level.
+### Use Cases
 
-### Persistence Support
+Prevents redundant items within a single batch or queue cycle:
+- API batching: Avoid duplicate IDs in the same batch request
+- Event processing: Deduplicate events before processing
 
-The `processedKeys` can be persisted via `initialState`, following the existing Pacer pattern (similar to RateLimiter):
+### Example
 
 ```typescript
-const savedState = localStorage.getItem('batcher-state')
-const batcher = new Batcher(fn, {
-  deduplicateItems: true,
-  initialState: savedState ? JSON.parse(savedState) : {},
-})
+const batcher = new Batcher<{ userId: string }>(
+  (items) => fetchUsers(items.map(i => i.userId)),
+  {
+    deduplicateItems: true,
+    getItemKey: (item) => item.userId,
+  }
+);
+
+batcher.addItem({ userId: 'user-1' }); // Added to batch
+batcher.addItem({ userId: 'user-2' }); // Added to batch
+batcher.addItem({ userId: 'user-1' }); // Ignored! Already in current batch
+batcher.flush(); // Processes [user-1, user-2]
 ```
 
 Fully opt-in with no breaking changes to existing behavior.