Decide whether you can reach the last index of an array of jump lengths.

Interview question: Jump Game

You are given an integer array `nums`. You are initially positioned at the array's first index, and each element in the array represents your maximum jump length at that position.

Return `true` if you can reach the last index, or `false` otherwise.

## Example
```
Input: nums = [2, 3, 1, 1, 4]
Output: true
Explanation: Jump 1 step from index 0 to 1, then 3 steps to the last index.

Input: nums = [3, 2, 1, 0, 4]
Output: false
Explanation: You will always arrive at index 3 no matter what, and its maximum jump length is 0, so you can never reach the last index.
```

- Each value tells you the maximum jump length from that index.
- You only need to know whether the last index can be reached, not the exact path.
- If you ever stand beyond the farthest reachable index, progress is impossible.

Understand Reachability

- One approach marks which indices are reachable from earlier indices.
- For every reachable index, mark all destinations within its jump range.
- This can work, but it may take O(n²) time in large arrays.

Brute Force or DP Idea

- A greedy scan is enough because jumps only move forward.
- Maintain `farthest`, the greatest index reachable so far.
- At each reachable index, update `farthest` with `i + nums[i]`.

Track the Farthest Reach

- If the current index is greater than `farthest`, there is no way to reach it, so return `False`.
- If `farthest` reaches or passes the last index, return `True`.
- Otherwise continue scanning reachable positions.

Detect Failure or Success

- The greedy invariant is that all indices up to `farthest` are reachable while scanning.
- Time complexity is O(n) because each index is visited once.
- Space complexity is O(1).