!per persistAsync

Breaks binary compatibility because adding new methods to Eventsourced
trait. Since akka-persistence is experimental this is ok, yet
source-level compatibility has been perserved thankfuly :-)

Deprecates:
* Rename of EventsourcedProcessor -> PersistentActor
* Processor -> suggest using PersistentActor
* Migration guide for akka-persistence is separate, as wel'll deprecate in minor versions (its experimental)
* Persistent as well as ConfirmablePersistent - since Processor, their
  main user will be removed soon.

Other changes:
* persistAsync works as expected when mixed with persist
* A counter must be kept for pending stashing invocations
* Uses only 1 shared list buffer for persit / persistAsync
* Includes small benchmark
* Docs also include info about not using Persistent() wrapper
* uses java LinkedList, for best performance of append / head on
  persistInvocations; the get(0) is safe, because these msgs only
  come in response to persistInvocations
* Renamed internal *MessagesSuccess/Failure messages because we kept
  small mistakes seeing the class "with s" and "without s" as the same
* Updated everything that refered to EventsourcedProcessor to
  PersistentActor, including samples

Refs #15227

Conflicts:
	akka-docs/rst/project/migration-guides.rst
	akka-persistence/src/main/scala/akka/persistence/JournalProtocol.scala
	akka-persistence/src/main/scala/akka/persistence/Persistent.scala
	akka-persistence/src/test/scala/akka/persistence/PersistentActorSpec.scala
	project/AkkaBuild.scala

akka-docs/rst/scala/code/docs/persistence/PersistenceDocSpec.scala

@@ -7,7 +7,7 @@ package docs.persistence
 import scala.concurrent.duration._
 import scala.language.postfixOps
 
-import akka.actor.{ Actor, ActorSystem }
+import akka.actor.{ Props, Actor, ActorSystem }
 import akka.persistence._
 
 trait PersistenceDocSpec {
@@ -314,7 +314,7 @@ trait PersistenceDocSpec {
     import akka.actor.ActorRef
 
     //#reliable-event-delivery
-    class MyEventsourcedProcessor(destination: ActorRef) extends EventsourcedProcessor {
+    class MyPersistentActor(destination: ActorRef) extends PersistentActor {
       val channel = context.actorOf(Channel.props("channel"))
 
       def handleEvent(event: String) = {
@@ -337,6 +337,42 @@ trait PersistenceDocSpec {
     }
     //#reliable-event-delivery
   }
+
+  new AnyRef {
+    import akka.actor.ActorRef
+
+    val processor = system.actorOf(Props[MyPersistentActor]())
+
+    //#persist-async
+    class MyPersistentActor extends PersistentActor {
+
+      def receiveRecover: Receive = {
+        case _ => // handle recovery here
+      }
+
+      def receiveCommand: Receive = {
+        case c: String => {
+          sender() ! c
+          persistAsync(s"evt-$c-1") { e => sender() ! e }
+          persistAsync(s"evt-$c-2") { e => sender() ! e }
+        }
+      }
+    }
+
+    // usage
+    processor ! "a"
+    processor ! "b"
+
+    // possible order of received messages:
+    // a
+    // b
+    // evt-a-1
+    // evt-a-2
+    // evt-b-1
+    // evt-b-2
+
+    //#persist-async
+  }
   new AnyRef {
     import akka.actor.Props