SubscriptionManager: Begin splitting up synchronizeSubscriberByFCP()

The motivation behind this is this FIXME:
https://github.com/freenet/plugin-WebOfTrust/blob/use-plugin-fcp-rewrite/src/plugins/WebOfTrust/ui/fcp/FCPInterface.java#L80
Summary: Currently, synchronizeSubscriberByFCP() does two things:
1) Read a full copy of all Identity/Trust/Score objects in the WOT
database.
2) Send it by FCP to the subscribing Client.

This obviously can take a very long time: We are potentially reading the
whole database, AND then sending it to the client by network. Especially
are we sending it with the sendSynchronous() function of the
FCPPluginClient - so the send call will block until all data has been
transfered.

To speed this up, the commit adds a second, abstract function to the
Subscription class: storeSynchronization(). It will do the above step
(1) = cloning the database. The old function
synchronizeSubscriberByFCP()'s JavaDoc is changed to require it to only
do the job of sending the clone by FCP.

NOTICE: This does NOT yet provide an implementation, fix the
implementation of synchronizeSubscriberByFCP() or the callers of it.
Thus, this starts the branch split-up-subscription-synchronization,
which will deal with necessary remaining adaptions.
SubscriptionManager: Add skeleton of storage class for synchronizations.

- This provides storage for the mechanism whose implementation began in
the previous commit 339b4646e3866239a6f1e06572a6507dc487f946.
- The class is introduced to ensure that the Notification class does not
have to be modified: We can now pass objects of this class to
Notification pretending they are the "newObject" of the Notification.
This is nice because modifying Notification itself to be able to store a
synchronization would have sucked: It pretty much relies on having an
oldObject and newObject, adding the synchronization as something
different would complexify its fine checks of validity of oldObject and
newObject.
SubscriptionManager: Adapt synchronizeSubscriberByFCP() implementations
to use SynchronizationContainer
WebOfTrustInterface: Add getAllIdentities()

- The function is already defined at the implementation class
WebOfTrust.
- It needs to be in the interface because class persistent has a member
of the interface type, and class IdentitiesSubscription in
SubscriptionManager will have to use getAllIdentities().
WebOfTrustInterface: Add getAllTrusts()

- The function is already defined at the implementation class
WebOfTrust.
- It needs to be in the interface because class Persistent has a
member of the interface type, and class TrustsSubscription in
SubscriptionManager will have to use getAllTrusts().
WebOfTrustInterface: Add getAllScores()

- The function is already defined at the implementation class
WebOfTrust.
- It needs to be in the interface because class Persistent has a
member of the interface type, and class ScoresSubscription in
SubscriptionManager will have to use getAllScores().
SubscriptionManager.SynchronizationContainer: Consume List instead of
ObjectSet

The part of the SubscriptionManager which creates the
SynchronizationContainer object will feed them from database queries
from objects of type WebOfTrustInterface, not WebOfTrust.
The interface returns Lists, not ObjectSets. ObjectSet implements List
by the way.
SubscriptionManager: Add missing import

See the previous commit.
SubscriptionManager.*Notification: Add constructors which eat a
SynchronizationContainer

Will be used in Subscription.storeSynchronization() implementations.
SubscriptionManager.*Subscription: Implement storeSynchronization()
SubscriptionManager: Rename storeSynchronization() to match standards

All database transaction functions in WOT which don't commit are called
*WithoutCommit().
SubscriptionManager.storeNewSubscriptionAndCommit(): Implement usage of
storeSynchronizationWithoutCommit().

- The synchronization has to be stored at the time of creation of the
Subscription: It has to happen before and right before the first
Notification is stored to ensure that the client is completely in sync.
So if we store it at the creation of a Subscription, no Notification can
slip in between.
- This sort of is a replacement for the below call
synchronizeSubscriberByFCP(): The old implementation of that did both
the job of creating the synchronization and sending it out to the
client. That call is not removed yet though because it won't compile
like this anymore anyway, so people will notice it, and it is more
suitable to remove it in a following commit which will deal with it in
the right place.
SubscriptionManager.SynchronizationContainer(): Use List instead of
ObjectSet

Same as with the constructor.
Add interface EventSource

- Is now implemented by Identity, Trust and Score
- Will be used by SubscriptionManager for cleaning up the way it uses
generics.
EventSource: Implement Serializable

This was already being implemented by all implementors of EventSource,
for the sole purpose of events (see class SubscriptionManager). So we
can move the declaration upwards to EventSource.
SubscriptionManager.Subscription: Be generic of type extending
EventSource

(EventSource = interface which Identity / Trust / Score implement.)

- This is better than the previous type parameter of extending
Notification: It will allow storage of Notification objects of different
types for a given subscription. This is needed to refactor the code of
subscription synchronizations to store them as objects of a special
Notification class - which will make the code a lot cleaner.
- I've made sure that the JavaDoc of all modified code is corrected.
- I've reviewed all changed functions to make sure that their callers /
callees are safe with the new type parameter.
- Line lengths are also fixed as I was touching the code anyway.
MockWebOfTrust: Add missing functions from parent interface

The functions were recently added to the parent interface but I forgot
to adapt MockWebOfTrust, which resulted in the compiler complaining
about missing implementations.
SubscriptionManager.Notification: Split off subclass
ObjectChangedNotification

- In following commits, I will need to introduce special Notification
classes which are not about an object changing, so they won't need
mOldObject / mNewObject. (Specifically, I will add
"BeginSynchroniztationNotification" / "EndSynchronizationNotification"
which will be marker objects to merely mark the begin and end of a
series of synchronization Notifications. Those markers won't contain any
data of their own)
- This commit only starts adapting both classes by showing where their
split point is. The following commits will compile-fix & JavaDoc them.
SubscriptionManager.(ObjectChanged)Notification: Fix constructors

- The constructor of Notification was moved to ObjectChangedNotification
as part of introducing ObjectChangedNotification. This commit moves the
code which belongs to parent class Notification back to it, while
keeping the rest in the child class.
- The visibility of the constructors is trimmed to default visiblity,
which is actually more restricted than "protected".
SubscriptionManager.(ObjectChanged)Notification: Fix
startupDatabaseIntegrityTest()

The startupDatabaseIntegrityTest() of Notification was moved to
ObjectChangedNotification
as part of introducing ObjectChangedNotification. This commit moves the
code which belongs to parent class Notification back to it, while
keeping the rest in the child class.