Could the compiler utilize OptimizedClosures.FSharpFunc?

I was doing some benchmarking today and was a bit surprised by some of the results.

The following function

```fsharp
let bar (f : 'a -> 'a -> 'a) (a:'a array) (b:'a array) =
Array.map2 f a b
```

is much faster than the next one, even though the previous one allocates a whole new array to store the results in.

```fsharp
let barInPlace (f : 'a -> 'a -> 'a) (a:'a array) (b:'a array) =
for i in 0..b.Length - 1 do
b.[i] <- f a.[i] b.[i]
```
In my case, I'd rather mutate one of the arrays instead of allocating a new one, since it can be quite large and `b` would be GC'd if not.

#### Repro steps

https://github.com/atlemann/OptimizedClosures

```bash
dotnet run -c Release -p OptimizedFunc.fsproj
```

#### Expected behavior

`barInPlace` to be faster than `bar`

#### Actual behavior

`bar` is much faster even though it allocates a whole new array

#### Known workarounds

Use OptimizedClosures.FSharpFunc in my own code, or inline all the things.

#### Related information

.NET Core SDK (reflecting any global.json):
Version: 2.2.104
Commit: 73f036d4ac

Runtime Environment:
OS Name: ubuntu
OS Version: 18.04
OS Platform: Linux
RID: ubuntu.18.04-x64