Simplify mkCacheInt32/mkCacheGeneric to use ConcurrentDictionary

[Copilot]

mkCacheInt32 and mkCacheGeneric were using Dictionary + lock syncObj, serializing all cache access including expensive metadata decode work.

Changes

• mkCacheInt32 / mkCacheGeneric: replaced Dictionary + lock with ConcurrentDictionary using TryGetValue / TryAdd. No locks, no syncObj.

let mkCacheInt32 lowMem _infile _nm _sz =
    if lowMem then (fun f x -> f x) else
    let cache = ConcurrentDictionary<int32, _>()
    fun f (idx:int32) ->
        match cache.TryGetValue idx with
        | true, v -> v
        | false, _ ->
            let v = f idx
            cache.TryAdd(idx, v) |> ignore
            cache.[idx]

GetOrAdd(key, factory) was not usable here — F# type inference cannot disambiguate it from GetOrAdd(key, value) when the value type is an unconstrained generic. TryAdd has no overloads and sidesteps the issue. On a concurrent cache miss, f idx may be computed twice (both GetOrAdd with factory and this pattern share that behaviour per the .NET docs), which is acceptable since these factories are pure metadata reads.

---

⌨️ Start Copilot coding agent tasks without leaving your editor — available in VS Code, Visual Studio, JetBrains IDEs and Eclipse.

[Copilot]

Pull request overview

This PR updates the AssemblyReader caching helpers to reduce contention during metadata decoding by replacing Dictionary + lock with ConcurrentDictionary, enabling concurrent cache access.

Changes:

• Replaced the lock-protected Dictionary caches in mkCacheInt32 and mkCacheGeneric with ConcurrentDictionary.
• Implemented cache lookup/insert via TryGetValue + TryAdd to avoid GetOrAdd overload-resolution issues in this context.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

cache.TryGetValue idx uses the F# out-arg-to-tuple translation, which allocates a tuple on every cache access (including hits). Since this cache is likely hot, consider using the byref overload (let mutable res = Unchecked.defaultof<_>; if cache.TryGetValue(idx, &res) then res else ...) to avoid per-call allocations. Also, after TryAdd you can return v directly when the add succeeds to avoid a second dictionary lookup.

[Copilot]

After computing v on a miss, the code does TryAdd and then unconditionally reads cache.[idx], which forces another lookup. Consider returning v when TryAdd succeeds (and only falling back to reading from the dictionary when it fails due to a concurrent add). This keeps the concurrent behavior but avoids extra work on every miss.