Added prototype of allocation free Match method (#146)

There is a simple Match method, which by design consumes 130x more CPU
and allocates 48 bytes with each call.
I strongly recommend to document this behavior or add implementation for
simple transformation, which directly returns mapped value.
As you can see in this code, which si more as prototype or
documentation, than real improvement, it is feasible to reduce the
method overhead.

Recommendations:
* Equal method in the function buddy causes boxing to object e.g.
allocations
* When delegate is not needed to transform result, than simple overload
can be used
* != is no longer recommended way for null comparison, since it can be
overloaded, use "is not null" instead

Not expecting this PR to be merged, should be used as reference only.

src/FuncSharp.Benchmarks/Object/IfMatchBenchmarks.cs

@@ -0,0 +1,46 @@
+using BenchmarkDotNet.Attributes;
+
+namespace FuncSharp.Benchmarks;
+
+[MemoryDiagnoser]
+public class IfMatchBenchmarks
+{
+    // Last Result - 14.9.2023 - 5.959 ns - 48 B
+    [Benchmark]
+    public void MapTrue()
+    {
+        var result = this.Map(true);
+    }
+
+    // Last Result - 14.9.2023 - 0.0046 ns - 0 B
+    [Benchmark]
+    public void MapValueTrue()
+    {
+        var result = this.MapValue(true);
+    }
+
+    // Last Result - 14.9.2023 - 0.0012 ns - 0 B
+    [Benchmark]
+    public void IfTrue()
+    {
+        var result = this.IF(true);
+    }
+
+    public int Map(bool source)
+    {
+        return source.Match(true, a => 5, a => 11);
+    }
+
+    public int MapValue(bool source)
+    {
+        return source.Match(true, 5, 11);
+    }
+
+    public int IF(bool source)
+    {
+        if (source)
+            return 5;
+
+        return 11;
+    }
+}