DiffBuilder: fix reindexing of operations involving nested paths

[angela-tarantula]

Fixes #138
Fixes #124

TL;DR

When DiffBuilder optimized a Remove + Add pair into a Move, some operations targeting nested positions within the same array were not reindexed correctly. The undo hooks only compared exact paths, leaving child paths (e.g., /0/x/1/y) unchanged even when /0/x is affected. This PR updates the undo logic to use prefix-based matching on parsed path segments and introduces helpers to safely adjust non-terminal path components.

Background / Problem

You can reproduce #138 and #124 by repeatedly running:

• Issue 138: https://github.com/stefankoegl/python-json-patch/blob/feff399d56d2755583d82c42b7e8359f170f3460/issue1.py
• Issue 124: https://github.com/stefankoegl/python-json-patch/blob/feff399d56d2755583d82c42b7e8359f170f3460/issue2.py

The core failure: once an Add/Remove pair is collapsed into a Move, operations that refer to deeper locations in the same array (e.g., /0/x/1/y) were not having their indices updated, because the undo hooks only matched exact string paths.

Example from #138: at the first relevant undo call, path == '0/x' but self.path == '0/x/1/y'; the equality check fails, so the subsequent operation’s index never decrements.

Root cause

• _on_undo_remove / _on_undo_add used if self.path == path, which only fires when the target is exactly the array path, not when the target is under that array.
• PatchOperation only exposed key (last path part), so we couldn’t adjust indices in the middle of the path (e.g., /0/x/1/y).

What this changes

1. Prefix matching by parts
   • _on_undo_remove / _on_undo_add now receive sub_parts and use _is_prefix(sub_parts, parts) to detect impact on nested paths, not just exact matches.
2. Part-wise path utilities
   • PatchOperation gains get_part/set_part and small increment/decrement helpers. MoveOperation mirrors these for from paths. This lets undo logic update indices in the middle of a path (not only the last part).
3. Call sites updated
   • DiffBuilder passes op.pointer.parts[:-1] into the undo hooks so they can adjust the correct array index segment.
4. Smaller correctness tweak
   • Align exception type in MoveOperation.from_key from TypeError to ValueError (consistent with key).

Design notes

• Helpers are intentionally minimal: they assume the caller passes a numeric segment where needed; bad calls will surface as errors rather than being silently ignored.
• We operate on unescaped parts (consistent with existing key semantics). Prefix checks at the parts-level avoid bugs caused by '/' and '~' in string paths.
• The undo hooks’ signatures change (private methods), which keeps the patch clear and localized.
• MoveOperation re-parses the from pointer in its helper methods, mirroring the existing from_key pattern. Caching is a possible follow-up if we want.

Backward compatibility

• Public API: unchanged. Kept the existing path property even though internal logic now prefers parsed parts.
• Private methods: _on_undo_remove / _on_undo_add now accept sub_parts rather than a string path.

Performance

• Complexity is unchanged. _is_prefix is O(k) in path length, same as the prior equality check in practice.

Tests

New regression tests (plus a variant with escaping):

• test_issue_138 — nested array index updates after a move optimization.
• test_issue_138b — same as above under a key containing '/' (escaping check).
• test_issue_124 — similar failure mode with different shapes/ordering.

All existing tests pass locally. Coverage is unchanged.

Migration / risk

• Risk is limited to consumers that subclass and override the private _on_undo hooks; they’ll need to switch to the sub_parts argument. Typical users of the public API are unaffected.
• Behavior change is strictly corrective. Patches that previously mis-indexed nested paths now apply correctly.