perf: don't recreate Pkg_rules.DB values

Before:
```
[ocaml-cohttp]$ hyperfine "dune build"
Benchmark 1: dune build
  Time (mean ± σ):      1.645 s ±  0.063 s    [User: 1.390 s, System: 0.246 s]
  Range (min … max):    1.580 s …  1.795 s    10 runs
```

After:
```
[ocaml-cohttp]$ hyperfine "dune build"
Benchmark 1: dune build
  Time (mean ± σ):     974.0 ms ±  18.6 ms    [User: 720.1 ms, System: 249.2 ms]
  Range (min … max):   953.6 ms … 1000.4 ms    10 runs
```

Signed-off-by: Ali Caglayan <[email protected]>

Author: Alizter

src/dune_rules/pkg_rules.ml

@@ -1199,24 +1199,12 @@ module DB = struct
       ; dep_pkg_digest : Pkg_digest.t
       }
 
-    let dep_equal (dep : dep) { dep_pkg; dep_loc; dep_pkg_digest } =
-      Pkg.equal dep.dep_pkg dep_pkg
-      && Loc.equal dep.dep_loc dep_loc
-      && Pkg_digest.equal dep.dep_pkg_digest dep_pkg_digest
-    ;;
-
     type entry =
       { pkg : Pkg.t
       ; deps : dep list
       ; pkg_digest : Pkg_digest.t
       }
 
-    let entry_equal (entry : entry) { pkg; deps; pkg_digest } =
-      Pkg.equal entry.pkg pkg
-      && List.equal dep_equal entry.deps deps
-      && Pkg_digest.equal entry.pkg_digest pkg_digest
-    ;;
-
     let entries_by_name_of_lock_dir
           (lock_dir : Dune_pkg.Lock_dir.t)
           ~platform
@@ -1270,8 +1258,6 @@ module DB = struct
     (* Associate each package's digest with the package and its dependencies. *)
     type t = entry Pkg_digest.Map.t
 
-    let equal = Pkg_digest.Map.equal ~equal:entry_equal
-
     let of_lock_dir lock_dir ~platform ~system_provided =
       entries_by_name_of_lock_dir lock_dir ~platform ~system_provided
       |> Package.Name.Map.values
@@ -1335,22 +1321,24 @@ module DB = struct
     ;;
   end
 
+  module Id = Id.Make ()
+
   type t =
-    { pkg_digest_table : Pkg_table.t
+    { id : Id.t
+    ; pkg_digest_table : Pkg_table.t
     ; system_provided : Package.Name.Set.t
     }
 
-  let equal t ({ pkg_digest_table; system_provided } as t') =
-    phys_equal t t'
-    || (Pkg_table.equal t.pkg_digest_table pkg_digest_table
-        && Package.Name.Set.equal t.system_provided system_provided)
-  ;;
+  let equal x y = Id.equal x.id y.id
 
-  let hash = `Do_not_hash
-  let _ = hash
-  (* Because t is large, hashing is expensive, so much so that hashing the db in Input.t
-     below slowed down the dune call in the test repo described in #12248 from 1s to
-     2s. *)
+  let create =
+    let table = Table.create (module Id) 16 in
+    fun ~pkg_digest_table ~system_provided ->
+      let id = Id.gen () in
+      let t = { id; pkg_digest_table; system_provided } in
+      Table.set table id t;
+      t
+  ;;
 
   let pkg_digest_of_name lock_dir platform pkg_name ~system_provided =
     let entries_by_name =
@@ -1393,7 +1381,7 @@ module DB = struct
                >>| Pkg_table.union
                      (Pkg_table.of_lock_dir lock_dir ~platform ~system_provided)
              in
-             { pkg_digest_table; system_provided })
+             create ~pkg_digest_table ~system_provided)
     in
     fun ctx ~allow_sharing -> Memo.exec of_ctx_memo (ctx, allow_sharing)
   ;;
@@ -1422,12 +1410,12 @@ module DB = struct
       | true ->
         let+ pkg_digest_table_all_dev_tools =
           Memo.Lazy.force Pkg_table.all_existing_dev_tools
-        and+ { pkg_digest_table = pkg_digest_table_default_ctx; system_provided = _ } =
+        and+ { pkg_digest_table = pkg_digest_table_default_ctx; _ } =
           of_ctx Context_name.default ~allow_sharing:true
         in
         Pkg_table.union pkg_digest_table_default_ctx pkg_digest_table_all_dev_tools
     in
-    ( { pkg_digest_table; system_provided }
+    ( create ~pkg_digest_table ~system_provided
     , pkg_digest_of_name
         lock_dir
         platform