Cache Invocable and prevent concurrent access into orc

[ls-1801]

Whenever invoked, the CallableFunction wrapper locates the executable within the LLVM context.
This makes calling a function not thread-safe as the underlying LLVM implementation is not thread-safe and introduces an unnecessary overhead.

For small functions, this lookup dominates the runtime. Note: This benchmark only measures the invocation. Compilation is done beforehand.

static nautilus::val<int> smallFunction(nautilus::val<int> i) {
	return i * 2;
}

----------------------------------------------------------------------
Benchmark                            Time             CPU   Iterations
----------------------------------------------------------------------
BM_smallFunctionCompiler          1187 ns         1183 ns       565135
BM_smallFunctionInterpreter       62.7 ns         62.5 ns     11918221

This PR caches the Invocable produced by the Compiler during construction of the CallableFunction and thus skips the lookup within the invocation.

----------------------------------------------------------------------
Benchmark                            Time             CPU   Iterations
----------------------------------------------------------------------
BM_smallFunctionCompiler          3.65 ns         3.65 ns    191092600
BM_smallFunctionInterpreter       63.1 ns         63.1 ns     11229368

Note: we can remove the release mode and benchmark commit and only pick the relevant commit

[PhilippGrulich]

I think the implementation works. We could also implement the caching in the MLIR executable, but I think both is fine.
I like the benchmarks, but please use Catch 2 Benchmark instead of Google Benchmark (and remove the module).
It would be cool to extend TracingBenchmark module to also have your benchmarks in https://nebulastream.github.io/nautilus/dev/bench/

[PhilippGrulich]

We could also just commit in this change the caching and extend the benchmarks in this PR. #73
In general, I think it would be cool to have execution benchmarks for a wider set of functions.