This makes it a fully-fleshed-out class for holding data.

This also pulls out the error message formatting logic into the error
itself.

This helps pyright better understand what's happening.

These provide a consistent call signatures into the parser. This also
decouples the tokenizer from the `Marker` class.

This makes it easier to read through the function, with a clearer name.

This draws a clear distinction between this and the user-visible
`Requirement` object.

This reduces how many regex patterns would be matched against the input
while also enabling the parser to resolve ambiguity in-place.

This allows for nicer error messages, which show the entire requirement
string and highlight the marker in particular.

This eliminates a point of duplication and ensures that the error
messaging is consistent.

This makes it easier to identify what position the parser was checking,
compared to relevant context to the reader.

This is more permitting and better handles tabs used as whitespace.

This follows what PEP 508's grammar says is a valid identifier.

This makes it possible for the arbitrary matches to be used within
requirement specifiers without special constraints.

This makes it clearer in the docstring grammars that a name without
any specifier is valid.

This makes the control flow slightly easier to understand.

This now exercises more edge cases and validates that the error messages
are well-formed.

This makes it easier to understand what the state of the parser is and
what is expected at that point.

This ensures that these error tracebacks correctly describe the
causality between the two errors.

This ensures that a marker with whitespace around it is parsed
correctly.

This is better aligned with the naming from PEP 508.

This ensures that these are only parsed when they're independent words.

The listed operators were incorrect.

This is more consistent with the rest of the format which is largely
whitespace agnostic.