Added mutation-summary library

  See here: https://code.google.com/p/mutation-summary/
  Cloned revision 5094194c (master branch)
Introducing automatic change tracking + major refactoring

 * The constructor syntax has changed  (on both document access strategies)
 * New API: `getPageRoot()` (on both document access strategies)
 * Removed the obsolete, timestamp-based change tracking
 * Removed all traces of the change notification events. No longer needed.
 * Added change tracking using the mutation-summary library
 * Now we accept filters for ignoring changes on some parts, and also
   ignore those parts while scanning. (This only works correctly if they
   are at the end of the document)
 * Don't freak out on corpus change; just update all the data structures
   incrementally, and publish a `corpusChanged` event
 * Enhanced the debug methods for verifying the integrity of our
   mapping data. (`testNodeMapping()` and `testAllMappings()`)
 * Renamed some of the internal fields and methods to start with _.
 * Various small fixes and debug output

Moved to a truly async API, hiding all internal details of scanning

Until now, some methods on the API of dom-text-mapper needed to do some
internal housekeeping, before they could actually calculate and return
correct results. But some of this house-keeping can not be done in a synchronos
way over PDF documents, and so to preserve comatibility on the API of
dom-text-mapper and all it's descendants, we are now moving to a fully async
API.

This means that before calling any of the impacted methods (listed below),
you should first call the `ready()` method with a callback, and the d-t-m
is ready for your queries, it will call your callback with a `state` object,
and you can then execute your queries on the returned `state` object.

This impacts the following methods:
 * `getInfoForPath()`
 * `getInfoForNode()`
 * `getContentForPath()`
 * `getLengthForPath()`
 * `getDocLength()`
 * `getCorpus()`
 * `getContextForCharRange()`
 * `getMappingsForCharRange()`
 * `getMappingsForCharRanges()`
 * `getIndexForPos()`

It is no longer supported to call these methods directly on d-t-m, they are
only exposed on the `state` object, which is passed with the callback,
after `ready()` has finished the housekeeping. (Even so, when calling
these methods, we still do the usual housekeeping stuff, because it's very
easy to disrupt the integrity of the data, even by routine operations.)

Update PDF for change tracking + async API

 * Added pdf-text-mapper (previously from Annotator's PDF plugin),
   which is a descendant of PageTextMapperCore
 * Some common code from DomTextMapper has been moved into a new class,
   TextMapperCore, which is now the common ancestor for DomTextMapper
   and PageTextMapperCore.
 * PageTextMapperCore has been updated to follow the API changes
   brought in by the automatic DOM change tracking and the async API.
 * PdfTextMapper has been updated to follow the same changes.
 * Added a _testAllMappings() method, for compatibility with dom-text-mapper
 * Cosmetic changes all around the place

Debugging and testing improvements

 * When discarding a node because it's empty, mark it (and all descendents of it)
   as irrelevent
 * When discarding a node because it's content is not present in it's parentn's
   content (so it's probably invisible), mark it (and all descendents of it)
   as mystery.
 * Improve the internal consistency checking methods to give more information,
   and add verbosity control. (Aso fix some bugs.)
 * Improve the internal consistenct checking methods to avoid giving false alarms
   on irrelevent and mystery nodes.
 * Improvement on reporting differences in data
Added workaround for one more selection API bug + disable some debug
Various bugfixes

 * Introducing calculation IDs. From now on, each round of calculating
   or updating mapping data gets an unique ID. This ID is used to
   differentiate between fresh and old data, when doing incremental
   updates of the mapping data. (Needed to solve #35).
 * In `_performUpdateOnNode()`,
   * never try to directly update the children of *irrelevant* nodes.
     Instead, going upwards, find a node that at least have a parent that
     is relevent, and work with that node. Fixes #34, problem 2
   * when dealing with irrelevant nodes, delay calling
     `_alterSiblingsMappingData()` to after the partial re-scan has
     finished. (Earlier, we have done it right away, but that can't work
     for previously irrevant nodes, which has no representation in the
     stringified form.) Fixes #35
 * In `_alterAncestorsMappingData()`,
   * handle irrelevant nodes by
     * directly assuming a 0 previous length,
     * getting the new parent content using `getNodeContent()` (because
       we can't insert the new position, because we don't know the right
       position)
     Fixes #34, problem 1
   * added lots and lots of internal error checking
 * In `selectNode()`, text nodes that only contain whitespace are no
   longer selected; hence these nodes are now always marked as irrelevant,
   and not mapped. This change was necessary because the handling of these
   nodes by WebKit's selection API was very fragile; selecting them
   sometimes resulted in ramdomly selecting the whole parent node.
   This was the cause of existence of the so-called *mystery nodes*,
   which caused many complications. They are all gone now. Fixes #32.
 * Various cosmetic changes
Make some internal error reports more civilized
Bugfix in incremental parent/sibling updates
Fix ignorePos calculation. Fixes #33
More debugging attemps, WIP
First attempt at new (shoot first, ask later) approach
Restore full observer functionality
Renamed some private fields / functions
Fixed some PDF bugs. Renamed more private fields.
Refactor getStart/EndInfoForNode functions

These two functions executed nearly the same code with only little difference
A common helper function called _calculatePositionIndex() is introduced,
which can do both start- and endInfo functionality
Coffee-style syntax improvement
hypothesis/dom-text-mapper#12 fix infinite loop on strange whitespace