Update version of cypher 2.1 compiler
Lock-free loading of relationships

Removes node lock previously used during loading of relationships. This
lock would contend with committing transaction and produce latency issues.
The lock prevented cache poisoning issues introduced by race conditions
between committer and reader(s).

To achieve a lock-free solution some guards had to be added for various
corner cases. These are:
- Committers are now aware of ot he fact that, and parries for,
  concurrent readers loading and caching relationships committed by the
  committer, before the committer has put them into cache itself,
  producing duplicates when the committer would add them.
  (Issue comes from the fact that store is updated before cache).
- Committers uses knowledge about how relationhips are stored on disk to
  be able to tell if any reader has loaded the relationships it has just
  written to the store, before updating the cache. This logic sits in a
  filter which is consulted before adding relationships to the cache.
- Nodes evicted from cache as part of being upgraded from sparse to dense
  now happens as part of updating the node instead of as a separate step
  during commit. This to also guard for concurrent readers.
- Simplification and reduction of code and logic of DenseNodeChainPosition
  where all individual chain positions are initialized eagerly, so that
  the filtering logic (as mentioned above) becomes simpler.
- Ordering of relationship-related records when applying transaction
  to store changed to: relationships, relationship groups, nodes so that
  additions to relationship chains are seen atomically by concurrent readers.
Rely on recovery for index statistics not flushed to counts store

There was a race condition between committing transactions and flushing
the counts store as part of taking an index online. This problem is
related to the fact that an index comes online non-transactionally, so
when that process tries to flush the counts store it would read the
lastCommittedTransactionID from the store, but that transaction might
not have been fully applied yet. We write the lastCommittedTransactionID
after we have successfully written the transaction to the log, but
before the transaction has been applied to the store files. With the
counts rotated before the transaction commits, the committing
transaction would encounter a counts store that already thinks the
transaction in question has been committed, and thus reject it.

Since flushing the counts store when taking an index online is only an
optimisation to avoid having to re-sample the index on recovery, it is
safe to simply remove the flushing on the counts store and pay the cost
of slightly longer recovery time instead.
Merge pull request #3536 from tinwelint/2.2-lock-free-load-rels

Lock-free loading of relationships
Merge pull request #3541 from davidegrohmann/2.2-update-version-cypher-compiler-2.1

Update version of cypher 2.1 compiler
Merge pull request #3543 from davidegrohmann/2.2-do-not-flush-counts-after-index-population

Rely on recovery for index statistics not flushed to counts store
Update fingerprint if plan is still valid

We have three guards in place for replanning:

1. How much time has passed since the query was planned?
2. How many transactions have been committed since the query was planned?
3. How much has the statistics changed since the query was planned?

These guards are ordered the way they are since it is assumed that the
later guards are more expensive than the former guards. Going to the
store for the current transaction ID is more expensive than looking at
the current time, and going to the store for several statistical
values is more expensive than just getting a single transaction id.

This has a problem in that after a guard has first failed, it will
continue to fail even if the later guards still keep the query
alive. Say that the database is very read heavy, so after the default
query TTL of 1 second has passed, guard (1) will always say that the
query needs to be re-planned. This means that we will always go to
disk to read the transaction ID, making each execution of the query
more expensive.

This commit solves this by updating the guards that say "replan" if a
later guard says not to replan. I.e. we should update the timestamp
for a query if we find that we have not seen that many transactions.