Big overhaul of orphan handling and reanchoring

Some new/changed features.
 * An annotation is an orphan, if it has targets, but no anchors.
 * An annotation is a half-orphan, if it has targets, and some anchors,
   but less anchors than targets. (Which means some targets are not anchored.)
 * The `.code` field of the anchoring strategies has been renamed to `.create`
 * Orphans and half-orphans are tracked in Annotator's
   `.orphans` and `.halfOrphans` fields, respectively.
 * All annotations are born (or loaded) as an orphan; their status changes
   if/when they are succesfully anchored.
 * The creation/removal of anchors automatically updates the annotation's
   orphan status.
 * `Annotator._anchorAnnotation(annotation, targetFilter, publishEvent)` will
   try to create any missing anchors for the given annotation,
   considering only the targets passing the (optional) targetFilter,
   without touching the anhors already established.
 * When `Annotator._anchorAllAnnotations(targetFilter)` is executed,
   it will try to create any missing anchors for all [half]orphan annotations,
   considering only the targets passing the (optional) targetFilter,
   without touching the anhors already established.
 * When the `.remove()` method is called on a given anchor, it will leave
   the corresponging annotation as an orphan or a half-orphan.
 * You can call the `.verify(reason, data)` method on a given anchor,
   which will verify whether the anchor is still valid, and remove it
   otherwise.
 * Anchoring strategies now have a new `.verify` field, which can be used to
   specify a method used to test whether a given anchor (created by that
   strategy) is still valid.
   This method will get the `reason` and `data` parameters, with information
   about the reason of this verification.
 * If an anchoring strategy does not specify a verification method, then the
   anchors created by it will always be considered invalided by any change.
 * `Annotator._verifyAllAnchors(reason, data)` will verify all anchors.
 * `Annotator._reanchorAllAnnotations(reason, data, targetFilter)` will verify
   all anchors, and then it will try to [re-]create any missing anchors using
   the `Annotator._anchorAllAnnotations()` method. (Also observing the
   optional target filter, while select the targets to anchor.)

Some gotchas to look out for:
 * Events:
   * When annotations are loaded, after all the anchoring is finished, an
     `annotationsLoaded` event is published.
   * A similar mechanism exists for the creation of annotations, too.
   * Likewise, if you call `_anchorAllAnnotations()` to re-create any missing
     anchors, an `annotationsLoaded` event will be published with the updated
     annotations.
   * **However**, if you are manually calling `_anchorAnnotation()` on a given
     annotation, you should set the `publishEvent` argument to true, so that
     the method will publish the announcement. Otherwise, no event will be
     published, resulting in various problems.

Fixes #39 and #40.