The `isEqual` method was implemented in the base class, which led to
wrong template types being used.

A subsequent commit will depend on this working correctly, including a test
breaking if not.

This prepares for making `bitfield` a fully-supported HILTI type. This
change only moves existing code over to HILTI without breaking
Spicy-side functionality. There are still HILTI-side pieces missing
for providing full support, which will come next.

We keep representing bitfields as a C++ tuple behind the scenes, but
no longer map it into a HILTI-side tuple as well. Instead `Bitfield`
is now a regular type with corresponding operators and runtime
functionality.

The one change to the C++ tuple representation is that we add an
additional hidden tuple element at the end that stores the original
integer value. That allows for displaying it (which we will do for now
only inside Spicy debug output) and could later also facilitate modifying
fields and reconstructing an integer.

Closes #1032. Using a typedef with bitfields works now.
Closes #1484. `&convert` can now refer to individual bitfields.

This works now:

    type Foo = unit {
      : bitfield(8) {
        x: 0..3;
        y: 4..7;
      };

      on %done {
        print self.x, self.y;
      }
};

Closes #1468.

…s anonymous.

This preservers the information if a field had a name even though
internally we do carry a generated dummy name around in that case. For
now, we just adapt `spicy-dump` to not print the dummy name in that
case in its text output. Later, Zeek will leverage this when
auto-generating record types.

We now render them as key/value form in both text and JSON output.

We were including offsets into spicy-dumps JSON output, but there was
no information in there saying which offsets belong to what field.
Turning `__offsets` from an array into a map indexed by field name now.

Spicy-dump now renders items of anonymous bitfields at the parent
level. Offsets are added accordingly as well if requested.