Find the minimum number of jumps needed to reach the last index.

Interview question: Jump Game II

You are given a 0-indexed array of integers `nums` of length `n`. You start at `nums[0]`. Each element `nums[i]` represents the maximum length of a forward jump from index `i`.

Return the minimum number of jumps to reach `nums[n - 1]`. The test cases are generated such that you can always reach the last index.

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

- From index `i` you may jump to any index up to `i + nums[i]`.
- You always start at index `0` and are guaranteed to reach the end.
- We want the **fewest** jumps to land on the last index.

Understanding the Problem

- Group indices by how many jumps it takes to first reach them.
- Level 0 is just index `0`; level 1 is everything reachable in one jump, and so on.
- The answer is the level number of the last index — exactly a shortest-path / BFS idea, done greedily.

Thinking in Levels (Implicit BFS)

- `end` marks the farthest index covered by the current number of jumps.
- `farthest` is the best index reachable while scanning the current level.
- When `i` reaches `end`, we have exhausted this level and must take another jump.

Tracking the Current Jump's Reach

- Iterate up to the second-to-last index (reaching it is enough).
- Continuously extend `farthest`. When `i == end`, increment `jumps` and push `end` out to `farthest`.
- This guarantees the minimum count because each jump greedily covers as far as possible.

The Greedy Scan

- Time: `O(n)` with a single pass over the array.
- Space: `O(1)` extra.
- A single element array needs `0` jumps, which the loop naturally returns.