refactor: simplify iterator.Try and remove unnecessary backtracking (#47)

## Description

`iterator.Try` previously copied the entire iterator and synced it back on success, causing an unnecessary heap allocation on every call.
This PR simplifies `Try` to save and restore the index directly, and removes the now-unused `Copy` and `Sync` methods.

- Rewrite `ScanRune` and `ParseRawToken` as peek-then-advance, eliminating the need for `Try` at leaf level.
- Remove redundant `Try` wrappers from `parseExpression`, `parseAbstraction`, `parseApplication`, `parseLet`, and `parseToken`, which are already disambiguated by their callers.
- Keep `Try` only where true backtracking is needed: `parseStatement`, which must choose between `parseLet` and `parseDeclare`.
- Fix pre-existing panic in saccharine `parseExpression` when the iterator is exhausted (added `Done()` guard).

### Decisions

- `Try` now operates on the original iterator instead of a copy, removing the confusing pattern where the callback's `i` was a different object than the caller's `i`.
- Removed `parseSoftBreak` and `parseHardBreak` helper functions since `ParseRawToken` no longer needs `Try` wrapping.

## Benefits

- Eliminates a heap allocation per `Try` call.
- Reduces nesting and indirection in all parse functions.
- Makes the code easier to follow by removing the shadow-`i` pattern.
- `Try` is now only used at genuine choice points in the grammar.

## Checklist

- [x] Code follows conventional commit format.
- [x] Branch follows naming convention (`<type>/<description>`). Always use underscores.
- [x] Tests pass (if applicable).
- [x] Documentation updated (if applicable).

Reviewed-on: #47
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>

pkg/iterator/iterator.go

@@ -19,18 +19,6 @@ func (i Iterator[T]) Index() int {
 	return i.index
 }
 
-// Copy returns a identical clone of the iterator. The underlying data structure
-// is not cloned.
-func (i Iterator[T]) Copy() *Iterator[T] {
-	return &Iterator[T]{items: i.items, index: i.index}
-}
-
-// Sync returns the iterator to the position of another. It is assumed that the
-// iterators both operate on the same set of data.
-func (i *Iterator[T]) Sync(o *Iterator[T]) {
-	i.index = o.index
-}
-
 // Get returns the datum at the current position of the iterator.
 func (i Iterator[T]) Get() (T, error) {
 	var null T
@@ -93,14 +81,14 @@ func (i *Iterator[T]) While(fn func(T) bool) {
 }
 
 // Try attempts to perform an operation using the iterator. If the operation
-// succeeds, the iterator is updated. If the operation fails, the iterator is
-// rolled back, and an error is returned.
+// succeeds, the iterator keeps its new position. If the operation fails, the
+// iterator is rolled back, and an error is returned.
 func Try[T any, U any](i *Iterator[T], fn func(i *Iterator[T]) (U, error)) (U, error) {
-	i2 := i.Copy()
+	saved := i.index
 
-	out, err := fn(i2)
-	if err == nil {
-		i.Sync(i2)
+	out, err := fn(i)
+	if err != nil {
+		i.index = saved
 	}
 
 	return out, err