Pi is correct that there are scenarios where a big bag could be sorted ahead of smaller bags that will empty faster. But to get into this circumstance, a very specific set of conditions have to occur:
1) many small bags are created
2) small bags are moved into large bag, without yet being released
3) spill happens, forcing a sort of the linked list
4) small bags go out of scope
This set of events seems fairly rare. And even when it does occur, the worst that happens is we are not as aggressive as we could be about cleaning the list. In the very worst case it will cause an early spill.
We cannot clean the entire list on every register call, as that is far too expensive (I tried it, it slowed performance by an order of magnitude on large scripts). We want to spill large bags first so that we spill as few bags as possible. We could change the code to copy the list and sort that copy, thus avoiding reordering the existing list. However, once we're in the spill code, we are in a low memory situation. Copying a potentially large list to sort it is a bad idea in that case. So I don't see a better solution.