Specifying ver1/ver2 even for `vercond="#BS...` for FO3 and later allows early rejection of that member for any non-BS 20.2 NIFs.

Unknown Short for FO3+ was two values, a byte and a bool.

Renamed "Num Skin Partition Blocks" and "Skin Partition Blocks" and combined the Partitions array into one row, as having a row separate for SSE was unnecessary.

For #76.  `calc` does not need to be supported and is only used for pre-serialization preparation of the data.  This can also be done by hand.

Some revisions also need to be made for #70 and #73 to account for another attribute with its own expression grammar and tokens.

However, the tokens introduced for `calc` will not be added to the tokens in the XML and will need to be explicitly supported if supporting `calc`.  They are:

1D array size (uses regex): `#LEN[(.*?)]#`
2D array size (uses regex): `#LEN2[(.*?)]#`

Ternary `?`: `#THEN#`
Ternary `:`: `#ELSE#`

Also removes any unnecessary `calculated` without replacement.

Additionally, `calc` is used to limit array size for the time being, though it's possible this should be done with its own attribute, such as `maxlen`.

FO4 DLC uses BSLightingShaderPropertyUShortController in 2 NIFs, but according to the CK it is not actually a functional block and spits out constant warnings. It is still needed in nif.xml for serialization though.

FO4 also adds two booleans for Env Map shader type for SSR.  These were previously marked as an Unknown Short.  These booleans are *not* synced with their values in the BGSM files except for generated meshes such as SCOL and precombined.

Havok serialization is separate from inheritance and so certain shapes that are actually convex were not considered such by nif.xml, which in turn excludes them from uses of `template="bhkConvexShape"`.

Created a fake base class to fix these issues.  Also, bhkConvexTransformShape no longer inheriting bhkTransformShape was more correct anyway, as the Ref type could be made more specific (bhkConvexShape).

Did some comment/description cleanup and some minor decoding.

For #76

For reduced ambiguity.  Adapting for this in Python is as easy as

```py
# XML Booleans
XML_TRUE = ["true", "1"]
XML_FALSE = ["false", "0"]

# Example
self.is_abstract = get('abstract') in XML_TRUE
```

Note "True" and "False" are not valid booleans in XML.  Only lowercase.

Named the compounds correctly after the actual structs,  separated the "Has Data" bool from the compound as it's not actually part of the struct, but before it in a for loop during (de)serialize.

Combined NiAdditionalGeometryData and the BS version into one compound when possible.  But the block can actually no longer be found in any official files, so the BS version is not very important.

Try to use element text whenever possible, and remove any unnecessary XML comments.  Soon the XML will be regenerated and so the XML comments need to be well formed and in predictable locations.

Finally added bhkPlaneShape, used once in SSE.  Added bhkCylinderShape which is possible to export from the official FO4 exporter.

Cleaned up much of the class descriptions and also added `binary="true"` to the padding bytes.

For #3, #76

Replaces all Flags types with real enums (where there were only two options) or a new bitfield type.

Bitfield mimics the bitfield syntax of C structs (Compounds), but also acts like Enum/Bitflags with the `storage` attribute in that the entire structure can simply be aliased to a basic type like `ushort`.

The `type` on each Bitfield member does **NOT denote size**.  Each member only takes up the bits that are defined by `width` and `pos`.  The `type` information is for casting for getters and setters.  That means for C structs, code generation would not use the type on each member, but the storage type instead.

For #70

Their use was discussed as being useful for shifting and masking values before sending as an ARG.

For #74

Implemented thanks to changes done in #76 for differentiating integral and "countable" i.e. can be used for sizes.

Marking types as boolean was also in #76, yet there were no errors for this lint; all the `cond` references that were not complex expressions were already boolean types.

For #76

The signed integeral types were marked as countable even though they should not be used for array sizes.  A negative value cannot be passed into an array size.   They are still integral though, so countable was split into `countable` and `integral`.

In addition,  added `boolean` to designate types that can toggle the presence of another member.

Also reordered items for `convertible` so that the referenced types come before the type referencing it, i.e. larger types first.

For #76

Also reorganized the basic types to be in a logical order.

For #70 and #76

Adopting the token syntax of the other tokens, TEMPLATE and ARG can now be treated the same as other tokens and differentiated from regular identifiers in a generic manner.

Now that any usage of `User Version 2` was actually just a `#BSVER#` token, reorganized the header information for Bethesda NIFs into the correct layout, and renamed the member to a more appropriate BS Version.

The global for #BSVER# uses the member of operator `\`, but as it is a token now it is free to be used however one wishes.

I split #BSSTREAMHEADER# into its own token in case the expression is ever reused (it used to be on multiple members before this reorganization).

Also put `Max Filepath` into BSStreamHeader where it belonged.

For #70

Have not decided on the non-escaped entities such as `==`, `|`, `||`, etc. yet, as at least `==` is much more readable than `#EQ#`.

Replaced all Version, User Version, etc. with their global tokens.

Also cleaned up NiTexturingProperty in the process.

Was completely unsupported and undocumented and unused by any software.  Replaced with arithmetic even though the decoding is likely wrong anyway.

For #76

Follow-up to fd66c975 for #70

For #76

For #76

`bool` type is something that has to be dealt with as it changes size.  Also it's marked as countable which should probably be analyzed... It shouldn't be used in array counts.

The `cond` attribute was being overloaded with multiple functions.  Conditions should be actual expressions, using local or inherited data.  Type checking inside of `cond` would also mean that you could do both in one expression, such as `cond="NiParticleSystem && Num Vertices > 0"` which doesn't make any sense.

So, `onlyT` and `excludeT` were made to serve that function.  Two attributes also means not having to use the unary not (!) in order negate the meaning.

Existing logic can simply alias the attributes to cond if need be.

For #70

For #70

Using tokens from #70 it is now feasible to version the Bethesda blocks.

Tokens are grouped by name and associated with a list of attributes.  Only listed attributes should be processed for tokens of that name.

Order of token groups matters.  Token strings can themselves include tokens, so any token group used in other tokens needs to come after.

The `ver` attribute was never actually formalized and just meant as a shorcut for using both ver1/ver2 on the same version.  `userver` was almost never used and `userver2` was becoming increasingly uncommon as most comparisons were switched to inequalities.

To make things easier, these should just be part of the expression.

Hey look at that, linting helped immediately.  Too bad I forgot to lint before committing the last commit.

Removed redundant descriptions for unknown values, removed incorrect descriptions for previously unknown values.  Any custom extension unknowns were prefixed with their relevant game.  Anything that was "Unk" was changed to "Unknown" for consistency.

A few inherited duplicates were also fixed in the process.

Added additional decoding from DEM decoding in 74c1aac6 since I erroneously added some of the decoding to NiPSParticleSystem in 1d62f161 anyway.

Did not decode any completely custom blocks.

Fixed inherited duplicate names, as well as the layout of BSTriShape for Particle emitter geometry data in SSE.

Left the name for Dynamic Data as "Vertices" though it is technically just called "Dynamic Data" in engine.  It contains the vertices and bitangent X for any BSDynamicTriShape, so the naming is apt.

Added V10_2_0_0__1 and scoped NiFurSpringController to it since it is a custom block only for that game.

Moved all the DEM specific stuff out of NiMesh and into compounds.  Did some decoding while I was at it.   There are many small customizations to other blocks for DEM, but I am not including them in this commit.  Regardless, the existing XML only worked for DEM1 and now at least some DEM2 will load fully.

First-pass implementation of `since`/`until` and `versions`.  Avoided nearly all Bethesda blocks for now, as they require the token system or would become absurdly repetitious.

First batch of fixed issues detected by the new linter.

Also some slight cleanup, plus an interitance fix a Bethesda particle class.