[lucic71]

This PR adds support for writing goto and goto_block in the following form:

let mut ret: i32 = 0;
goto_block!({
     '__entry: {
         if n < 0 {
             ret = -1;
             goto!('out);
         }
         ret = 100;
     }
     'out: {
         return ret;
     }
});

This is equivalent to the following C code:

int f() {
  int ret;
  if (n < 0) {
    ret = -1;
    goto out;
  }
  ret = 100;
out:
  return ret;
}

goto_block is already used by the switch-with-fallthrough macro internally. I modified its syntax from a list of label = { ... } to label: { ... } so that rustfmt can format it properly.

Then, I added GotoRewriter to rewrite each goto!('label) into { __s = <target index>; continue '__sm; }. Whenever GotoStateMachine hits a goto macro, it calls GotoRewriter to generate the following state machine:

{
    let mut __s: u32 = 0;
    '__sm: loop {
        match __s {
            0u32 => {
                if n < 0 {
                    ret = -1;
                    __s = 1; continue '__sm;   // <- was goto!('out)
                }
                ret = 100;
                __s = 1; continue '__sm;       // fall-through to next arm
            }
            1u32 => {
                return ret;
                break '__sm;                   // last arm: exit
            }
            _ => break '__sm,                  // match exhaustiveness
        }
    }
}

Finally, to support nested goto_blocks, for example a switch inside a goto_block, I added StateMachineNames which gives a unique name to each state machine so that each goto targets the correct state machine.

After this PR is merged, I will add the codegen counterpart in the cpp2rust/ dir.

A few limitations about how goto will work:

• local variables of a function that contains goto will be hoisted outside the goto_block so that all arms of the goto_block macro can see them. c2rust also does this. All hoisted variables will be default initialized.
• the rust compiler cannot prove that all paths of the code inside the loop of the state machine return. I reality the loop always returns because the C behavior is preserved. To suppress the rustc error, I added a panic at the end of the function: panic!("ub: non-void function does not return a value");