Make "contents" check available for individual bits?
I have one example, and only one currently, so might not be worth spending time at all, where a bit field is specified to always be 0. Because of that I thought of making that clear on runtime using `contents`, but that only works on bytes and because it's a bit field with additional bits set to unknown values, I can't provide a full byte to check against. Additionally, at least the Java runtime's `ensureFixedContents` reads data on it's own and therefore doesn't support reading individual bits.

My example is pretty simple:

    - id:       is_res
      type:     b1
      #contents: [0x00]
    - id:       is_prm
      type:     b1
    - id:       fcb_or_acd_raw
      type:     b1
    - id:       fcv_or_dfc_raw
      type:     b1
    - id:       function_raw
      type:     b4

From my understanding we have at least two choices: One would be to define a different syntax for `contents` and bit-fields, e.g. `contents-bits`, so that it can be mapped to a different implementation which behaves the same like now, only using bit-reading logic instead of that for bytes. The benefit of the current approach is that an exception is thrown before storing any invalid data in the parser.

OTOH I thought it might be a good idea to simply remove the reading logic entirely from `ensureFixedContents` and instead change to a approach first reading the data and storing it into the parser and afterwards ensuring it's content by forwarding both the read and expected data to compare. Bytes and bits should map to `byte[]` in both cases. This doesn't make any difference regarding stream position etc. when the exception is thrown, but parser state is different, because it would now contain invalid data. The good thing is that one wouldn't need to find an additional syntax for `contents` and bits.

What do you think?