...ithreads functionality doesn't even come close to what it would take for this to work.

Pardon me, but poppycock!.

From the scant information supplied, you want to fetch a sequence of pages concurrently and then re-assemble them, in the original order.

Off the top of my head, I'd do something like this:

1. Create 2 Thread::Queues

   One to supply the "$seq_no:$url" to the threads,

   One to return the fetched page "$seq_no:$contents" to the main thread.

2. Start a number of threads that:
   1. Create their own user agents.
   2. Loop over the inputQ, waiting for a "$seq_no:$url", terminating when they dequeue undef.
   3. Split the seq_no & url.
   4. fetch the url.
   5. Prepend the sequence number to the contents and enqueue to the outputQ.
   6. loop till undef.
3. Main thread enqueues the "$seq_no:$urls" to the inputQ.
4. Main: waits for inputQ to empty.
5. Main: enqueues 1 undef per thread.
6. Main: Sort outputQ by the prepended seq_no into the correct order, splits off the sequence numbers and joins the contents.
7. Processes the output.

There is plenty of scope in there for overlapping the appending and processing with the fetching. The main thread can dequeue the returns, process those that come out in the right order and store out-of-sequence returns in a hash for easy lookup. Each time it completes processing one set of content, it looks first in the hash to see if the next in sequence is available. If not, it goes back to dequeuing until it gets it.

With a little more ingenuity, the main thread could start another thread to do the processing that waits on a third Q. The main thread then dequeues and either re-queues to the processing thread or buffers in a hash.

The processing thread then performs the final disposal of the processed accumulated data, whilst the main thread blocks waiting for it to finish.

It's actually a very good use of threads and very straight forward to code.