IL: make ILTypeDefs, ILMethodDefs thread-safe

[auduchinok]

InlineDelayInit is used in ILTypeDefs and ILMethodDefs. It's not thread safe and creates unneeded closured for all types and methods to be possibly imported.

The thread safety problem can be seen here:

    member x.Value =
        match x.func with
        | null -> x.store
        | _ ->
            let res = LazyInitializer.EnsureInitialized(&x.store, x.func)
            x.func <- null
            res

There's a chance that x.func may be set to null on another thread before EnsureInitialized is executed, leading to exception and possibly corrupted compiler state.

It wasn't a problem before, as all this compiler logic was single-threaded. Nowadays we try to move parts of the analysis to separate threads (think about 1) skipping implementation files and then analyzing them concurrently, 2) sharing ILModuleDef between multiple background builders in an IDE, 3) moving some parts of the analysis like pattern match compilation to a later parallel stage). All of this makes it possible for this problem to occur if two threads try to import the same namespace or methods at the same time.

In addition to not being thread-safe, InlineDelayInit always allocated another closure for the dictionary factory as it used array value. It also allocated Func and kept delegates to store the factories.

The current implementation uses a monitor to fix thread safety, doesn't allocate Func delegates, and stores a single array factory lambda instead of two.

Since there're many instances created and we want to use less memory here, we can also shave another empty object and a reference field from the type if we decide that it's fine to lock on this, but that's a questionable trick. Or we could pass/use some shared object instead.

It's also possible to remove some added repetition, but I've only managed to do it at the expense of additional allocations when creating the array or dictionary, so I didn't commit these changes.