Add builtins.memoise - #782

`builtins.memoise f x` returns `f x`, but caches the result so that
subsequent calls with an equal `f` and `x` don't call `f` again. A
typical application is avoiding repeated instantiations of Nixpkgs with
the same arguments. For example, evaluating

  (builtins.memoise (import nixpkgs) {
    system = "x86_64-linux";
    config = { allowUnfree = true; };
    overlays = [ ];
  }).hello.drvPath

10 times (with fresh but equal arguments each time) goes from 8.4s and
480 MB to 1.5s and 129 MB (debug build).

This is based on 0395b9b from 2018,
but rewritten to be thread-safe with parallel evaluation:

* Comparing arguments can cause arbitrary evaluation, so it must not
  happen while holding a lock on the cache. Instead, the cache maps a
  hash of the function and argument (in weak head normal form) to an
  immutable, prepend-only list of entries. A lookup reads the head of
  the list, compares with the entries without holding a lock, and adds
  a new entry only if no other thread has added one in the meantime;
  otherwise it compares with the new entries and retries. Entries root
  their values using RootValue (rather than relying on
  traceable_allocator, which takes the global GC lock) and are
  reference-counted, so a lookup in progress keeps its list alive if
  the cache is cleared.

* The cached result is an application thunk `f x`, so if several
  threads look up the same call concurrently, `f x` is evaluated only
  once and the other threads wait for it.

Equality is structural and lazy (values are only forced as far as
needed), but stricter than `==`: integers are distinct from floats,
string contexts must be equal, derivations are not compared by
`outPath`, and lambdas are equal only if their expression and
environment pointers are equal.
`builtins.memoise` is strict in both arguments. Beyond that, values
that fail to evaluate during the comparison are considered unequal.

The cache is cleared by `resetFileCache()` (e.g. `:reload` in the
REPL), since memoised results may depend on files. The number of
hits and misses is reported by `NIX_SHOW_STATS`.

The builtin requires the `memoise` experimental feature.

Assisted-by: Claude Opus 5.5 <noreply@anthropic.com>