Enhancement request: Something like Lisp cond for type selection
We currently have `if`, which allows elements to appear or disappear based on a logical expression, and `case`, which allows a type to be selected based on matching a literal value with an optional default case. I sometimes need something which is halfway between these, like the `cond` expression in Lisp, where you can choose between a variety of alternatives based on a series of logical expressions, with an optional default case.

To make this concrete, here is a definition that is the best I can do in the current implementation (taken from [here](https://github.com/Deep-Symmetry/beat-link/blob/5da596c526768a3f6df40d044754845f6397dc67/kaitai/pdb.ksy#L803-L808)):
```yaml
        type:
          switch-on: length_and_kind
          cases:
            0x40: device_sql_long_ascii
            0x90: device_sql_long_utf16be
            _: device_sql_short_ascii(length_and_kind)
```
The problem is that this is not correct, what I have labeled as the default should only be chosen if `length_and_kind` is odd. So I would much prefer to be able to write something like this:
```yaml
        type:
          switch-on-cond:
            case:
              expr: length_and_kind == 0x40
              result: device_sql_long_ascii
            case:
              expr: length_and_kind == 0x90
              result: device_sql_long_utf16be
            case:
              expr: (length_and_kind % 1) > 0
              result: device_sql_short_ascii(length_and_kind)
```
Note that in this structure I actually don’t want a default, and it should act like `case` when nothing matches in this situation. To support defaulting, one could either use a `case` clause with an `expr` that was always true (evaluation should stop with the first `case` that succeeds), or a `default: some_type` in place of a final `case:` subtree.