The theory behind caching aborted Operations was that they would fail
again anyway. However, under memory pressure Operations may fail due to
failing allocations and will succeed in the future once memory pressure
drops, if we kept them in the cache we wouldn't try again.

While we are at it, improve wording and use an extra abort() method on
Operation.

this allows to mark elements as pinned, meaning they will not be dropped
due to capacity constraints or clear() but only with an explicit erase
(e.g. as used for aborted queries).

The Operation is owned so it should be a unique_ptr not shared_ptr. This
will hopefully save quite a few memory barriers (for atomic ref
counting) and is cleaner.

We also prevent the copying of QueryExecutionTrees which was previously
done in several places and may be expensive but is definitely
unexpected.

They are actually kept in the order of the triple file as seen by the
setVariableColumn() calls in QueryPlanner.cpp

The name always suggested that it carried context per query while in
fact it held the SubtreeCache which should really live for many queries.
Since it is indeed useful to have a per query context we move the
SubtreeCache outside the QueryExecutionContext and make it truly per
query.

This allows to pin all subtrees of a query to the cache and have that as
a per query option. On the QLever server this is exposed as the
"pinsubtrees" URL param. If set to true all subtrees in the query will
be cached. This is especially useful for completion queries and the
like.

In the entries we now only store a pointer to the key inside the hash
map

This reverts commit 9209326.

Both currently keep separate _variableColumnMap hash maps. This commit
tries to always init the one in the QueryExecutionTree from the
_rootOperation we have anyway. Sadly it seems they aren't just redundant
but diverge somewhere as this commit currently fails to pass the e2e
tests.