Enum type definitions will appear (generated from BTF) in c_definitions
part of program if bpftrace detects an enum is being used. So when we
parse the c_definitions, we need to keep track of all the enum metadata
we see.

The newly added map is structured for lookup efficiency on the
upcoming symbolization codepath.

Enums in C, C++, and bpftrace are treated as regular integers in the
backend. Thus, rather than create a new type in bpftrace (which comes
with great complexity and maintenance overhead), encode enums as an
integer with a name. That is all an enum is, after all. This way all
existing codepaths which deal with integers also work with enums without
code change.

CreateEnum() and IsEnumTy() are added to work with the new pseudo-type.

tracepoint and kfunc args are laid out in a custom struct definition and
then parsed by clang_parser. So we need to remember in the type
system which struct fields are enums so that if the user accesses the
enum field, bpftrace knows it can be symbolized.

We'll need this information when processing enum variants the user
directly referenced. For example: `print(MY_VARIANT_NAME)`.

Add tests to ensure we are parsing the data we expect in clang_parser.

Teach semantic analyser to track enum type information in the type
system. We need this type information to propagate to format string
validation and handling so we can both allow printing enums symbolically
as well as symbolize correctly at runtime.

Just for convenience when working with strings.

Previously, semantic analysis used this logic to validate that for
printf() the format string matched the provided arguments. It was also
the only user.

In the next commit we want to change formatting of a single given
argument based on the type specified in the format string. To do this
reliably and consistenly, we'll need to reuse this logic during runtime.

This commit factors out token extraction so it can be reused.

We'll need the token information for enum symbolization in order to
reliably choose whether to format the opaque format string with an
integer or string.

Note that token extraction is done on first use and cached. This
amortizes the performance penalty on the output fast path.

This commit allows the user to print enums with %s format string
specifier. At this point, the type system can determine if an expression
is an enum and which enum it is.

So at output time, the machinery can now do lookups to map from enum
type and value to enum variant.

This is super useful for users who want an efficient way to symbolize
enums. Previously if they wanted to do this they'd have to manually
symbolize in the script. And that's bad b/c it's both inconvenient and
slows down the kernel fast path.

Before, we were removing duplicated whitespace in all directives.
Somehow this actually worked. But the next test I want to add has
whitespace sensitive output. So fix the whitespace disturbance.

Add a smattering of semantic analyser and runtime tests to check that
enum symbolization indeed works.

Toss it into printf(). Hopefully it's not too obscure of a feature and
people can still find this.