StepExamplesIterable._iter_arrow drops samples for non-zero ranks for single-sharded

### Describe the bug

As titled

### Steps to reproduce the bug

Running following Python script:

```
"""
Reproducer for HuggingFace datasets 4.x bug:
StepExamplesIterable._iter_arrow drops samples for non-zero ranks
when Arrow batches have size 1 (e.g. single-shard streaming WebDataset).

Bug: split_dataset_by_node with world_size > num_shards should fall back
to round-robin sample distribution via StepExamplesIterable. The __iter__
path works correctly, but the _iter_arrow path (new in 4.x) processes
each 1-row Arrow batch independently, so range(offset, 1, step) is empty
for any offset > 0.

Works in datasets 3.x (no Arrow path). Broken in datasets >= 4.0.

Tested with: datasets==4.8.1
"""

import io
import tarfile
import tempfile
import os

from datasets import load_dataset
from datasets.distributed import split_dataset_by_node


def create_single_shard_webdataset(num_samples: int = 32) -> str:
    """Create a minimal single-shard WebDataset tar file."""
    tmpdir = tempfile.mkdtemp()
    tar_path = os.path.join(tmpdir, "data-0000.tar")

    with tarfile.open(tar_path, "w") as tar:
        for i in range(num_samples):
            # Add a .txt file for each sample (minimal valid WebDataset)
            key = f"{i:06d}"
            content = f"sample {i}".encode()
            info = tarfile.TarInfo(name=f"{key}.txt")
            info.size = len(content)
            tar.addfile(info, io.BytesIO(content))

    return tmpdir


def main():
    import datasets
    print(f"datasets version: {datasets.__version__}")

    # Create a single-shard WebDataset
    data_dir = create_single_shard_webdataset(num_samples=32)
    print(f"Created test dataset at: {data_dir}")

    # Load as streaming (the bug only affects streaming mode)
    ds = load_dataset(
        data_dir,
        split="train",
        data_files={"train": "*.tar"},
        streaming=True,
    )
    print(f"Dataset num_shards: {ds.num_shards}")
    print()

    # Simulate 8 GPUs: split_dataset_by_node should distribute
    # 32 samples across 8 ranks (4 per rank) via round-robin fallback
    world_size = 8
    print(f"Splitting across {world_size} ranks:")
    total = 0
    for rank in range(world_size):
        split_ds = split_dataset_by_node(ds, rank=rank, world_size=world_size)
        count = sum(1 for _ in split_ds)
        total += count
        status = "OK" if count > 0 else "BUG: got 0 samples!"
        print(f"  Rank {rank}: {count} samples  {status}")

    print()
    expected_per_rank = 32 // world_size  # 4
    ranks_with_no_data = sum(
        1 for rank in range(world_size)
        if sum(1 for _ in split_dataset_by_node(ds, rank=rank, world_size=world_size)) == 0
    )
    if ranks_with_no_data > 0:
        print(
            f"BUG: {ranks_with_no_data}/{world_size} ranks got 0 samples!\n"
            f"Expected ~{expected_per_rank} samples per rank.\n"
            f"Root cause: StepExamplesIterable._iter_arrow processes each\n"
            f"1-row Arrow batch independently. range(offset, 1, step) is\n"
            f"empty for any offset > 0, so only rank 0 gets data."
        )
    else:
        print("All samples distributed correctly.")


if __name__ == "__main__":
    main()

```

### Expected behavior

Expected to return round robin data on each rank

### Environment info

reproduced in version 4.8.1 and 4.8.2