Benchmark EnsoMultiValue and speed it up

[JaroslavTulach]

EnsoMultiValue with visible and hidden types as introduced by:

• Intersection types & type checks #11600

hasn't been optimized for speed and is known to perform certain operations magnitude slower than regular enso values.

• write benchmarks
• speed the operations up

[JaroslavTulach]

Here is a the basic benchmark:

diff --git engine/runtime-benchmarks/src/main/java/org/enso/interpreter/bench/benchmarks/semantic/ArrayProxyBenchmarks.java engine/runtime-benchmarks/src/main/java/org/enso/interpreter/bench/benchmarks/semantic/ArrayProxyBenchmarks.java
index 1327a37cee..19acb8eac0 100644
--- engine/runtime-benchmarks/src/main/java/org/enso/interpreter/bench/benchmarks/semantic/ArrayProxyBenchmarks.java
+++ engine/runtime-benchmarks/src/main/java/org/enso/interpreter/bench/benchmarks/semantic/ArrayProxyBenchmarks.java
@@ -42,13 +42,30 @@ public class ArrayProxyBenchmarks {
         """
         import Standard.Base.Data.Vector.Vector
         import Standard.Base.Data.Array_Proxy.Array_Proxy
+        from Standard.Base import Integer
+
         sum arr =
             go acc i = if i >= arr.length then acc else
-                @Tail_Call go (acc + arr.at i) i+1
+                v = arr.at i
+                sum = acc + v
+                @Tail_Call go sum i+1
             go 0 0
 
+        type Rational
+                Number quotient:Integer fraction:Integer
+
+        Rational.from (that:Integer) = Rational.Number that 1
+
         make_vector n =
-            Vector.new n (i -> 3 + 5*i)
+            Vector.new n i->
+                r = 3 + 5*i
+                r:Integer
+
+        make_int_rational_vector n =
+            Vector.new n i->
+                r = 3 + 5*i
+                r:Integer&Rational
+
         make_computing_proxy n =
             Array_Proxy.new n (i -> 3 + 5*i)
         make_delegating_proxy n =
@@ -70,6 +87,9 @@ public class ArrayProxyBenchmarks {
       case "sumOverVector":
         test_builder = "make_vector";
         break;
+      case "sumOverMultiIntegerRationalVector":
+        test_builder = "make_int_rational_vector";
+        break;
       case "sumOverComputingProxy":
         test_builder = "make_computing_proxy";
         break;
@@ -94,6 +114,11 @@ public class ArrayProxyBenchmarks {
     performBenchmark(matter);
   }
 
+  @Benchmark
+  public void sumOverMultiIntegerRationalVector(Blackhole matter) {
+    performBenchmark(matter);
+  }
+
   @Benchmark
   public void sumOverComputingProxy(Blackhole matter) {
     performBenchmark(matter);

It piggy backs on Array_Proxy benchmarks, but it shows the difference:

• benchOnly ArrayProxyBenchmarks.sumOverVector takes 0.062 ms/op
• benchOnly ArrayProxyBenchmarks.sumOverMultiIntegerRationalVector takes 4.814 ms/op

e.g. the r:Integer&Rational is 80x slower. It shouldn't be that slow! We don't need the same speed, but this kind of slowdown is too much.

Real benchmark in the PR is just inspired by this diff.