initial connector work
Upcasters can now convert one object to an arbitrary number of objects.

This feature allows Upcasters to upcast an event into zero, one or multiple
events. Previously it was only possible to upcast an event to exactly one
other event.

The upcaster interface as well as the serializer interface have been changed
to support this feature. Both deserialization and upcast methods now return
a list of objects. The same goes for upcasting and deserialization of types,
where each element in the list of types should correspond with the element on
the same index in the list of deserialized objects.

Lazy deserialized objects now have an extra index field that points to the
index of the deserialized object on the list of deserialized objects. Meaning
that multiple lazy deserialized can have a pointer to the same serialized
object but will, upon deserialization, return different objects.
Merge branch 'master' into upcaster-demultiplexer

Conflicts:
	core/src/main/java/org/axonframework/eventstore/SerializedDomainEventData.java
	core/src/main/java/org/axonframework/eventstore/jpa/AbstractEventEntry.java
	core/src/main/java/org/axonframework/saga/repository/jpa/SagaEntry.java
	core/src/main/java/org/axonframework/serializer/JavaSerializer.java
	core/src/main/java/org/axonframework/serializer/Serializer.java
	core/src/main/java/org/axonframework/serializer/Upcaster.java
	core/src/main/java/org/axonframework/serializer/UpcasterChain.java
	core/src/main/java/org/axonframework/serializer/XStreamSerializer.java
	core/src/test/java/org/axonframework/domain/AbstractAggregateRootTest.java
	core/src/test/java/org/axonframework/domain/JavaSerializationTest.java
	core/src/test/java/org/axonframework/eventstore/jpa/DomainEventEntryTest.java
	core/src/test/java/org/axonframework/eventstore/jpa/JpaEventStoreTest.java
	core/src/test/java/org/axonframework/serializer/UpcasterChainTest.java
	core/src/test/java/org/axonframework/serializer/XStreamSerializerTest.java
	incubator/google-app-engine/src/main/java/org/axonframework/gae/eventstore/EventEntry.java
	incubator/mongo/src/main/java/org/axonframework/eventstore/mongo/EventEntry.java
	integrationtests/src/test/java/org/axonframework/integrationtests/domain/StructuredAggregateSerializationTest.java
Upcasting is now a task of the event store instead of the serializer.

Upcasting is now a task of the event store which makes the serializer concept more loosely coupled
and the serializer's interface more easier to use. To accomplish this the LazyDeserializingObject now
contains a LazyUpcastingObject. The LazyUpcastingObject is responsible for upcasting a given serialized
object only once and only when getObject is called on it.

The LazyDeserializingObject keeps track of which part of the upcasted object it is interested in de-serializing.
Meaning that each entry in a set of upcasted events that all have the same original event are wrapped in a
LazyDeserializingObject, all these wrappers point to a different index on the same LazyUpcastingObject.
Minor changes during code review
SimpleEventScheduler now guarantees removal of token when executed

When an Event is published, the token is now guaranteed to be removed, even if publication results in an error.
Updated EhCache dependency version
Fixed potential GC race condition issue in Saga

The SagaCache holds a weak reference to saga entries. However, a transaction holding a SagaEntry will not prevent the cached sage from being cleaned up. When cleaned up, it may be reconstructed without seeing the uncommitted changes held by the EntityManager. SagaEntry now holds a (hard) reference to the Saga being stored, to prevent cleanup while the transaction is running.
Fixed deadlock possibility in SagaManager

This deadlock could appear when a Saga dispatches a command which in turn publishes an event that invokes the same saga. The code in the Saga is executed using a lock on the saga. If the command cannot be executed directly in the UoW, the lock on the saga is released. If another thread is doing a similar operation, it may hang on the aggregate's lock, while keeping the lock on the saga. This issue is resolved by making sure a lock is held while the thread participates in an active UoW.
Fixed deadlock possibility in SagaManager

This deadlock could appear when a Saga dispatches a command which in turn
publishes an event that invokes the same saga. The code in the Saga is
executed using a lock on the saga. If the command cannot be executed directly
in the UoW, the lock on the saga is released. If another thread is doing a
similar operation, it may hang on the aggregate's lock, while keeping the
lock on the saga. This issue is resolved by making sure a lock is held while
the thread participates in an active UoW.
Refactoring of DisruptorCommandBus. It now uses UnitOfWork and CommandHandler interceptors.
Renamed RingBufferConfiguration
Improved documentation and test coverage of the DisruptorCommandBus
UnitOfWork listeners are now notified of commit and cleanup
Added callback support to DisruptorCommandBus
Added CommandTargetResolver to the disruptor configuration

Instead of relying on a MetaData field, the Command Target resolver is used to
resolve the aggregate identifier of the aggregate to pre-load. The version is ignored.
Improved module pom

Fixed groupId (removed incubator part) and added name and description.
Updated disruptor-commandbus with core API changes
Moved disruptor commandbus out of incubator
Added automatic recovery from corrupted aggregate state to DisruptorCommandBus

When the state of an aggregate could not be published correctly, that aggregate is marked a corrupt. The DisruptorCommandBus
 will automatically recover from that state by evicting the aggregate from the cache and ignoring any changes until eviction is
 complete.