[EH] Support reading/writing of delegate

[aheejin]

This adds support for reading/writing of the new delegate instruction
in the folded wast format, the stack IR format, the poppy IR format, and
the binary format in Binaryen. We don't have a formal spec written down
yet, but please refer to WebAssembly/exception-handling#137 and
WebAssembly/exception-handling#146 for the informal semantics. In the
current version of spec delegate is basically a rethrow, but with
branch-like immediate argument so that it can bypass other
catches/delegates in between.

delegate is not represented as a new Expression, but it is rather
an option within a Try class, like catch/catch_all.

One special thing about delegate is, even though it is written
within a try in the folded wat format, like

(try
  (do
    ...
  )
  (delegate $l)
)

In the unfolded wat format or in the binary format, delegate serves as
a scope end instruction so there is no separate end:

try
  ...
delegate $l

delegate semantically targets an outer catch or delegate, but we
write delegate target as a try label because we only give labels to
block-like scoping expressions. So far we have not given Try a label
and used inner blocks or a wrapping block in case a branch targets the
try. But in case of delegate, it can syntactically only target try
and if it targets blocks or loops it is a validation failure.

So after discussions in #3497, we give Try a label but this label can
only be targeted by delegates. Unfortunately this makes parsing and
writing of Try expression somewhat complicated. Also there is one
special case; if the immediate argument of try is the same as the
depth of control flow stack, this means the 'delegate' delegates to the
caller. To handle this case this adds a fake label
DELEGATE_CALLER_TARGET, and when writing it back to the wast format
writes it as an immediate value, unlike other cases in which we write
labels.

This uses DELEGATE_FIELD_SCOPE_NAME_DEF/USE to represent try's label
and delegate's target. There are many cases that try and
delegate's labels need to be treated in the same way as block and
branch labels, such as for hashing or comparing. But there are routines
in which we automatically assume all label uses are branches. I thought
about adding a new kind of defines such as
DELEGATE_FIELD_TRY_NAME_DEF/USE, but I think it will also involve some
duplication of existing routines or classes. So at the moment this PR
chooses to use the existing DELEGATE_FIELD_SCOPE_NAME_DEF/USE for
try and delegate labels and makes only necessary amount of changes
in branch-utils. We can revisit this decision later if necessary.

Many of changes to the existing test cases are because now all trys
are automatically assigned a label. They will be removed in
RemoveUnusedNames pass in the same way as block labels if not targeted
by any delegates.

This only supports reading and writing and has not been tested against
any optimization passes yet.

---

Original unfolded wat file to generate test/try-delegate.wasm:

(module
  (event $e)
  (func
    try
      try
      delegate 0
    catch $e
    end)

  (func
    try
      try
      catch $e
        i32.const 0
        drop
        try
        delegate 1
      end
    catch $e
    end
  )
)

[aheejin]

The unfolded wat file used to generate try-delegate.wasm file is this:

(module
  (event $e)
  (func
    try
      try
      delegate 0
    catch $e
    end)

  (func
    try
      try
      catch $e
        i32.const 0
        drop
        try
        delegate 1
      end
    catch $e
    end
  )
)

This is to test whether delegate within try body or catch body works. When parsing we create a block within each of try and catch body, but we shouldn't make those delegates target those blocks because it will be a validation failure, so we have to remap those delegates to the correct try.

[aheejin]

This is not related to delegate but I just found out we don't have any tests that test nested try-catch, so I added one here

[kripken]

Nice! This is simpler and cleaner than I'd thought could be done, given the complexity.

Basically lgtm, aside from the comments.

[aheejin]

This comment block was just moved