Stricter checks for enum definitions

[HertzDevil]

This PR makes it an error to reopen an enum with an explicit base type that is different from its original definition:

enum Foo; X; end
enum Foo : UInt8; end # Error: enum Foo's base type is Int32, not UInt8

enum Bar : UInt16; X; end
enum Bar : UInt32; end # Error: enum Bar's base type is UInt16, not UInt32
enum Bar; end          # okay, base type not explicitly specified

It also improves overflow detection so that it works immediately after an enum member with a value is declared: (previously the overflow error would trigger on the subsequent enum member afterwards, or not at all)

enum Foo1
  A = 0x7FFFFFFF
  B # Error: value of enum member B would overflow the base type Int32
end

@[Flags]
enum Foo2
  A = 0x40000000
  B # Error: value of enum member B would overflow the base type Int32
end

@[Flags]
enum Foo3 : UInt32
  A = 0x80000000
  B # Error: value of enum member B would overflow the base type UInt32
end

Note that the overflow criterion for signed flags enums is the same as normal multiplication. And indeed this is the case when the overflowing member is succeeded by a valueless member:

@[Flags]
enum Foo4
  A = 0x20000000
  B
  C # Error: value of enum member C would overflow the base type Int32
end

Some code in the wild might assume it is okay to have Foo2::B == -0x80000000 here. IMO this is a bug rather than a breaking change.

Finally, visit_enum_member's implementation is largely refactored, and there are fewer parameters and return values now. (It also removes one of the compiler's remaining non-forwarding uses of an **options parameter.)