Fix quadratic key disambiguation in lock files

LockFile::toJSON() assigns each node a unique key, disambiguating
collisions by appending _2, _3, and so on. The search restarted at 2 on
every collision, so the k-th node sharing a base name cost k iterations
and the whole pass was O(n^2) in the number of colliding nodes.

This is easy to hit in practice. Every flake that depends on many other
flakes accumulates one "systems", "flake-compat" or "nixpkgs" node per
dependency, and they all share a base name. Because the serialized lock
file is passed to call-flake.nix on every evaluation, the cost is paid
by `nix eval`, `nix flake metadata` and `nix flake lock` alike, not just
when writing the file back out.

Track the highest suffix already handed out per base key and resume from
there. The insert check is retained, so a name that legitimately appears
in the lock file (e.g. an input actually called "systems_2") is still
skipped over and the resulting keys are unchanged.

Measured on a flake with n inputs that each pull in their own "systems",
timing `nix eval` of an output that touches no input:

    inputs   nodes    before     after    speedup
       500    1000     0.64s     0.15s       4.3x
      1000    2000     0.88s     0.16s       5.5x
      2000    4000     3.05s     0.28s      10.9x
      4000    8000    11.49s     0.54s      21.3x

Lock files produced before and after are byte-identical, verified on the
cases above, on a lock file containing pre-existing "systems_2",
"systems_3" and "systems_5" inputs, and on an existing real-world flake.

Co-authored-by: Sergei Zimmerman <sergei@zimmerman.foo>

Author: fzakaria

src/libflake/lockfile.cc

@@ -1,4 +1,5 @@
 #include <boost/unordered/unordered_flat_set.hpp>
+#include <boost/unordered/unordered_flat_map.hpp>
 #include <nlohmann/json.hpp>
 #include <assert.h>
 #include <boost/unordered/unordered_flat_set_fwd.hpp>
@@ -187,14 +188,20 @@ std::pair<nlohmann::json, LockFile::KeyMap> LockFile::toJSON() const
     KeyMap nodeKeys;
     boost::unordered_flat_set<std::string> keys;
 
+    /* The next numeric suffix to try for a given base key. Suffixes start at 2, since the
+       unsuffixed key occupies the _1 slot. Used to amortise name deduplication by memoising
+       the lower bound of suffixes that definitely cannot be used. */
+    boost::unordered_flat_map<std::string, int> keySuffixes;
+
     auto dumpNode = [&](this auto & dumpNode, std::string key, ref<const Node> node) -> std::string {
         auto k = nodeKeys.find(node);
         if (k != nodeKeys.end())
             return k->second;
 
         if (!keys.insert(key).second) {
-            for (int n = 2;; ++n) {
-                auto k = fmt("%s_%d", key, n);
+            auto & suffix = keySuffixes.try_emplace(key, 2).first->second;
+            for (;;) {
+                auto k = fmt("%s_%d", key, suffix++);
                 if (keys.insert(k).second) {
                     key = k;
                     break;