I think the problem is that `++:` is O(n) (n = vector size) but `+:` is to O(1). For example, given

    private var theStash = (1 to 10000).toVector

then 

    private[akka] def prepend(others: immutable.Seq[Int]): Unit =
      others.reverseIterator.foreach(env ⇒ theStash = env +: theStash)

    1 to 10000 foreach (i ⇒ prepend(List(i)))

takes only 187 ms, whereas 

    private[akka] def prepend(others: immutable.Seq[Int]): Unit =
      theStash = others ++: theStash

    1 to 10000 foreach (i ⇒ prepend(List(i)))

takes 1279 ms. But with a vector size of 50000

    private var theStash = (1 to 50000).toVector

the first case still takes ~190 ms whereas the second already 3825 ms.

This problem came up in the performance test where the user puts a single message on the user stash (per iteration) and the processor stash contains 5000 messages on average. This single message is then prepended to the vector in each iteration. Prepend is only used in the `EventsourcedProcessor` when the user calls `unstashAll` on the user stash. A large processor stash (vector) as in this example is common under high load.