feat(NNS): Parallelize dkg calls in recovery CUP creation (#4634)

This PR parallelises the calls to `create_initial_dkg_dealings` and
`compute_initial_i_dkg_dealings` during subnet recovery.

The rationale is that soon we will migrate the
`compute_initial_i_dkg_dealings` call to the `reshare_chain_key`
endpoint, which also supports resharing VetKD keys. Unlike existing IDKG
reshares, a VetKD reshare can take up to two DKG intervals after the
call has been made, since under the hood it uses the Remote NiDKG
protocol, the same one that `create_initial_dkg_dealings` uses.

If we didn't parallelizs these calls, creating a recovery CUP could
potentially take more than 4 DKG intervals since we would do two rounds
of Remote NiDKG.

There is a similar situation in `create_subnet`, however, I decided not
to parallelize this because:
1. The call sites of `ceate_initial_dkg_dealings` and
`compute_initial_i_dkg_dealings` is further apart, which would require
more code reshuffling
2. There is less time pressure when creating a Subnet than when
recovering one, so the additional 2 DKG intervals are less of an issue.

Nonetheless, if you think it makes sense to also parallelise
`create_subnet`, let me know.

Author: Sawchord

rs/registry/canister/src/mutations/do_recover_subnet.rs

@@ -97,15 +97,6 @@ impl Registry {
                 RegistryVersion::new(pre_call_registry_version),
             );
 
-            let response_bytes = call(
-                CanisterId::ic_00(),
-                "setup_initial_dkg",
-                bytes,
-                Encode!(&request).unwrap(),
-            )
-            .await
-            .unwrap();
-
             let initial_chain_key_config =
                 payload
                     .chain_key_config
@@ -115,9 +106,18 @@ impl Registry {
                             .expect("Invalid InitialChainKeyConfig")
                     });
 
-            let chain_key_initializations = self
-                .get_all_initial_i_dkg_dealings_from_ic00(&initial_chain_key_config, dkg_nodes)
-                .await;
+            // Call setup_initial_dkg and compute_initial_i_dkg_dealings in parallel.
+            // Since both calls may take up to 2 DKG intervals to complete, this speeds up generation of a recovery cup.
+            let (response_bytes, chain_key_initializations) = futures::join!(
+                call(
+                    CanisterId::ic_00(),
+                    "setup_initial_dkg",
+                    bytes,
+                    Encode!(&request).unwrap(),
+                ),
+                self.get_all_initial_i_dkg_dealings_from_ic00(&initial_chain_key_config, dkg_nodes)
+            );
+            let response_bytes = response_bytes.unwrap();
 
             if let Some(initial_chain_key_config) = initial_chain_key_config {
                 // If chain key config is set, we must both update the subnet's chain_key_config