Bytecode instrumentation cache

[eupp]

Currently bytecode instrumentation can take significant time. Moreover, it is performed for each scenario even when testing the same data structure.

In the context of the adaptive planning feature #158, instrumentation time can interfere with the invocations time, thus making it harder to get reliable prediction for the average invocation time.

This PR provides simple instrumented bytecode caching, thus mitigating the performance overhead of instrumentation.

[ndkoval]

Please use putIfAbscent(..) { .. } instead

[eupp]

Here the usage of computeIfAbsent in fact makes code more verbose, because:

1. instrument throws checked exception IOException which has to be handled inside lambda.
2. bytecodeCache might be null and it is Java file, so we cannot use Kotlin's ? syntax sugar.

[eupp]

Here is how the code looks like:

                if (bytecodeCache != null) {
                    bytes = bytecodeCache.computeIfAbsent(name, className -> {
                            try {
                                return instrument(originalName(className));
                            } catch (IOException e) {
                                throw new RuntimeException(e);
                            }
                        }
                    );
                } else {
                    bytes = instrument(originalName(name));
                }

[eupp]

We can remove checked exception from instrument, but still after this there would be two similar calls to instrument (in case when we have the cache, and when we don't)