Too large allocation because of doubling last allocation

Consider this scenario:

* allocate 10 bytes
* allocate 1 Mb
* allocate 10 bytes

`bumpalo` will allocate 3M, because third allocation will create third chunk double the size of second chunk.

Instead `bumpalo` could do the following: if allocation size is larger than 1M, always allocate in the fresh chunk of size exact of allocation size, attach it to the tail of current chunk, and then continue allocating in the current chunk.

This will break this invariant of `iter_allocated_chunks`:

```
/// The chunks are returned ordered by allocation time, with the most
/// recently allocated chunk being returned first, and the least recently
/// allocated chunk being returned last.
```

Start by tracing bumpalo's chunk allocation path and reading the iter_allocated_chunks documentation; reproduce the 10-byte/1 MiB/10-byte sequence to inspect chunk sizes and ordering. Confirm the proposed exact-size large-chunk behavior and add regression coverage for allocation size and iteration order.

Written by the indexing model from the issue text.