Refactor command to make is shorter

Description

I noticed that most functions of commands had a similar shape, so I made it more compact by making calls to the same function for all the commands, with different parameters

List of changes

• Factorize the match.receiver by writing a new async function
• Write code to convert to serialize (which was the main thing that didn't allow the previous point)
• Write a macro to further factorize the code that was left in functions

Additional notes

I think that the first two changes should be kept as it's pretty clear was it is done and it organizes the code better. For the macro part, while it indeed shortens the code, macros are generally a bit harder to read and maintain, so we may want to keep code very similar between functions.

The reason for using a macro is that the number of arguments for each variant of DragoonCommand is not always the same, so factorizing means writing a function with a variable number of parameters (thus the macro).

I think it would be interesting to run this first after building it, to check that everything works as intended (since we don't have tests yet).

src/commands.rs

@@ -170,13 +170,13 @@ macro_rules! dragoon_command {
     ($state:expr, // the current state we are in
         $variant:ident // the type of DragoonCommand we want to use
         $(,)? // optional comma, allows to not leave a trailing comma when there is nothing behind
-        $($t:ident),*) // the list of the parameters for the given variant, separated by comma, 0 or more of them
+        $($variant_args:ident),*) // the list of the parameters for the given variant, separated by comma, 0 or more of them
         // note that the sender is automatically added, since it's common to all the variants
          => {
         {
         let (sender, receiver) = oneshot::channel(); // create a channel
 
-        let cmd = DragoonCommand::$variant {$($t,)* sender}; // build the command
+        let cmd = DragoonCommand::$variant {$($variant_args,)* sender}; // build the command
         // for example, when calling `dragoon_command!(state, Listen, multiaddr)` the expanded result will be:
         // `let cmd = DragoonCommand::Listen {multiaddr, sender}`
         // note that as variant and all the t are captured as ident, there is no need to write the corresponding field name for each variable