Find the length of the longest valid well-formed parentheses substring.

Interview question: Longest Valid Parentheses

Given a string containing just the characters `'('` and `')'`, return the length of the longest valid (well-formed) parentheses substring.

## Example
```
Input: s = ")()())"
Output: 4
Explanation: The longest valid parentheses substring is "()()".
```

## Constraints
* `0 <= s.length <= 3 * 10^4`
* `s[i]` is `'('` or `')'`.

- A valid parentheses substring must have every closing parenthesis matched with a previous opening parenthesis.
- When a closing parenthesis cannot be matched, any substring crossing it is invalid.
- We need a way to remember the most recent invalid boundary and unmatched opening positions.

Track Valid Substring Boundaries

- Store indexes rather than characters so lengths are easy to compute.
- Start the stack with `-1`, a sentinel boundary before the string begins.
- Push indexes of `(` characters because they may match future `)` characters.

Use a Stack of Indexes

- For `)`, pop one index because it attempts to close the most recent unmatched `(`.
- If the stack becomes empty, this `)` is unmatched, so push its index as the new invalid boundary.
- Otherwise, the current valid substring starts after `stack[-1]`.

Handle Closing Parentheses

- After a successful match, `stack[-1]` is the index just before the current valid substring.
- The substring from `stack[-1] + 1` through `i` is therefore valid.
- Its length is `i - stack[-1]`.

Why the Length Formula Works

- The sentinel handles valid substrings that start at index 0.
- Resetting the sentinel after an unmatched `)` handles broken regions.
- Time complexity is O(n), and extra space complexity is O(n).