Performance - #467

- StringType.is_*() methods: replace set membership tests with identity
  comparison ("self is X or self is Y"). Enum singletons make "is"
  correct and it avoids creating a temporary set and hashing enum values
  on every call. These methods are called per-character during string
  parsing.

- Parser._current/_idx/_marker: access Source._current etc directly,
  bypassing an unnecessary property indirection layer. With ~2M accesses
  per parse this eliminates millions of redundant function calls.

- _parse_string: hoist loop-invariant delim.is_singleline(),
  delim.is_multiline(), delim.is_basic(), and delim.unit into local
  variables before the per-character loop. The delimiter type never
  changes within the loop (it is set once, after the opening delimiter
  is consumed).

- Use tuple instead of list for "in" check on control char codes
  (tuples are faster for containment tests).

Co-authored-by: Copilot <[email protected]>

Three structural fixes that remove redundant work during parsing:

1. Table.raw_append: after appending a dotted key, used to read the
   value back via Container.__getitem__ (which creates a throwaway
   SingleKey, searches the map, etc). Now uses dict.__getitem__ on
   the Container directly — same result, no intermediate objects.

2. Container.append: checked 'key in self' which goes through
   MutableMapping.__contains__ → __getitem__ → item() → SingleKey.
   Changed to 'key in self._map' — a direct dict lookup on the
   internal map that already uses Key objects as keys.

3. SingleKey.__init__: the bare-key character check was rebuilding
   string.ascii_letters + string.digits + '-_' on every call.
   Now uses the pre-computed BARE constant from toml_char.

Together these eliminate ~46k unnecessary SingleKey creations and
~26k unnecessary Container.__getitem__ calls per 500 parses.

Co-authored-by: Copilot <[email protected]>

Structural changes to avoid unnecessary work:

1. Extract _parse_table_header() and pass pre-parsed headers to
   _parse_table(), eliminating the peek-then-reparse pattern where
   every table header was parsed twice (once to peek, once for real).
   Removes _peek_table() entirely.

2. Reorder _parse_array() to check for closing bracket before
   attempting to parse a value, eliminating 3 speculative
   UnexpectedCharError constructions per parse (each requiring
   an expensive _to_linecol() call that scans the full source).

Total function calls reduced from 6.3M to 5.88M per 500 parses.

Co-authored-by: Copilot <[email protected]>

During parsing, Container.append performed expensive formatting work
(indentation adjustment, display name invalidation, insertion ordering)
that was immediately short-circuited by the _parsed flag — but the
isinstance checks guarding those blocks still ran through the slow
ABCMeta path every time.

Guard all formatting-only logic with 'if not self._parsed:', avoiding
~250k isinstance calls (including ~188k through ABCMeta) and ~38k
ends_with_whitespace / _previous_item calls per 500 parses.

Co-authored-by: Copilot <[email protected]>

Replace the Parser delegation layer (self._current, self.inc(),
self.mark(), self.extract(), self.end()) with direct access to the
Source object (src = self._src; src._current, src.inc(), etc.) in
all hot methods. This eliminates ~3M Python function calls per 500
parses — one extra frame per property access or method delegation.

The delegation wrappers are retained for use by less performance-
sensitive code paths.

Co-authored-by: Copilot <[email protected]>