Adds CleanupService for auto-closing ResourceIterators on GC.

o Adds AutoCleanupResourceIterator to be used by the core API
o IndexNotOnlineException caus we gonna need it next
o Neo4jJobScheduler now uses daemon threads
Hooks in CleanupService for all ResourceIterators

o Ensures that IAGD dependency resolver only performs correct casts
o Javadocs for ResourceIter*
o Makes Node.getLabels return a ResourceIterable
o Makes IndexHits ResourceIter*
Add exception when user tries to do shortest path without START in cypher.

o A temporary guide for the user, until we support shortest path without a start clause.
Documents ResourceIterator.close() in the core API tutorial & related fixes

o Adds close() example to schema indexing tutorial
o Adds note on how to handle ResouceIter*
o Fix: Makes ROProxy use ResourceIter*
o Fix: Makes ha/lock/LockableNode use ResourceIter*
Added missing license header
Merge pull request #671 from boggle/close-index-readers

Close index readers
Flushes index population progress and status
Imports
Added internal support for running transactions via the REST API.
  o Introduced new transactional endpoint, supporting cypher only, as per
    design discussion with Ian and Tobias.
  o Uses it's own streaming JSON serialization and deserialization, in order
    to support handling errors that occur after streaming results has started.
  o Include configurable transaction timeout, defaulting to 60 seconds.
  o Uses the new Kernel API, creating a StatementContext for each statement,
    and doing transaction management through TranactionContext.rollback/commit.
    The latter done by wrapping TranactionContext in a decorator that does necessary
    fiddling with TxManager.
  o Compared performance between Jetty, Jetty + Servlet and Jetty + Servlet + Jersey.
    No noticable difference found (300 op/s/client each), so went for the high-level
    jersey approach.
  o Includes documentation for how to use the API.

Design overview:

  TransactionalService
          |
  TransactionalActions
          |
      ----|------------|-------------------|
      |                |                   |
  KernelAPI     ExecutionEngine     TransactionRegistry
                                           |
                                      TimeoutTask

  TransactionalService handles the HTTP abstraction, delegating incoming requests to appropriate
  TransactionalAction methods. This includes wrapping incoming streams in serialization and deserialization
  classes.

  TransactionalActions handles the domain logic of creating, storing, committing and rolling back transactions,
  as well as executing statements against them.

  KernelAPI is actually wrapped by a class called TransitionalPeriodTransactionMessContainer, which implements
  the KernelAPI interface, and adds decorators to hide the current messiness of transaction management from the
  rest of the implementation. This abstraction leaks slightly in TransactionRegistry, I could not find a way around that.

  TransactionRegistry stores transactions that are currently opened and unused in a thread safe way. It is called
  intermittently by an external task (handled by the kernels JobScheduler), which asks the registry to evict transactions
  that have been idle longer than a user-defined threshold.

Missing:
  o StatementContext is not yet passed to Cypher, only the mechanism for creating it is in place.
    A separate commit should make appropriate changes in cypher to provide for injecting statement context.
  o RuntimeException when calling ExecutionResult.iterator().next() is handled gracefully from a Transaction POV,
    but result sent back to user will potentially be invalid JSON. This needs to be resolved before publicly
    documenting this feature.
  o Logging is minimal so far, only transaction eviction is logged, and only if rollback fails. Improved logging
    should be added before documenting this feature.

Details:
  o For an overview of how the API works, please refer to the TransactionFunctionalTest integration test.