feat: persistent inline extmarks and configurable EOL format (#97)

* refactor(buffer): split extmark namespace into `ns_eol` and `ns_inline`

Problem: all extmarks shared a single `pending` namespace, making it
impossible to selectively clear position-sensitive extmarks (overlays,
highlights) while preserving stable EOL virtual text (due dates,
recurrence).

Solution: introduce `ns_eol` for end-of-line virtual text and
`ns_inline` for overlays and highlights. `clear_marks()` and
`apply_extmarks()` operate on both namespaces independently.

* feat(buffer): track line changes via `on_bytes` to keep `_meta` aligned

Problem: `_meta` is a positional array keyed by line number. Line
insertions and deletions during editing desync it from actual buffer
content, breaking `get_fold()`, cursor-based task lookups, and extmark
re-application.

Solution: attach an `on_bytes` callback that adjusts `_meta` on line
insertions/deletions and tracks dirty rows. Remove the manual
`_meta` insert from `open_line()` since `on_bytes` now handles it.
Reset dirty rows on each full render.

* feat(buffer): clear only inline extmarks on dirty rows during edits

Problem: `TextChanged` cleared all extmarks (both namespaces) on every
edit, causing EOL virtual text (due dates, recurrence) to vanish while
the user types.

Solution: replace blanket `clear_marks()` with per-row
`clear_inline_row()` that only removes `ns_inline` extmarks on rows
flagged dirty by `on_bytes`. EOL virtual text is preserved untouched.

* feat(buffer): re-apply inline extmarks after edits

Problem: inline extmarks (checkbox overlays, strikethrough, header
highlights) were cleared during edits and only restored on `:w`,
leaving the buffer visually bare while editing.

Solution: extract `apply_inline_row()` from `apply_extmarks()` and
call it via `reapply_dirty_inline()` on `InsertLeave` and normal-mode
`TextChanged`. Insert-mode `TextChangedI` still only clears inline
marks on dirty rows to avoid overlay flicker while typing.

* fix(buffer): suppress `on_bytes` during render and fix definition order

Problem: `on_bytes` fired during `render()`'s `nvim_buf_set_lines`,
corrupting `_meta` with duplicate entries and causing out-of-range
extmark errors. Also, `apply_inline_row` was defined after its first
caller `reapply_dirty_inline`.

Solution: add `_rendering` guard flag around `nvim_buf_set_lines` in
`render()` so `on_bytes` is a no-op during authoritative renders.
Move `apply_inline_row` above `reapply_dirty_inline` to satisfy Lua
local scoping rules.

* feat(buffer): add configurable `eol_format` for EOL virtual text

Problem: EOL virtual text order (category → recurrence → due) and the
double-space separator are hardcoded in `apply_extmarks()`. Users cannot
reorder, omit, or restyle metadata fields.

Solution: Add `eol_format` config field (default `'%c  %r  %d'`) with
`%c`, `%r`, `%d` specifiers. `parse_eol_format()` tokenizes the format
string; `build_eol_virt()` resolves specifiers against `LineMeta` and
collapses literals around absent fields.

* ci: format

doc/pending.txt

@@ -648,6 +648,32 @@ Fields: ~
                          virtual text in the buffer. Examples: `'%Y-%m-%d'`
                          for ISO dates, `'%d %b'` for day-first.
 
+    {eol_format}         (string, default: '%c  %r  %d')
+                         Format string controlling the order, content, and
+                         separators of end-of-line virtual text on task lines.
+                         Three specifiers are available:
+
+                           `%c`  category icon + name (`PendingHeader`)
+                           `%r`  recurrence icon + pattern (`PendingRecur`)
+                           `%d`  due icon + date (`PendingDue` / `PendingOverdue`)
+
+                         Literal text between specifiers is rendered with the
+                         `Normal` highlight group and acts as a separator.
+                         When a specifier's data is absent (e.g. `%d` on a
+                         task with no due date), the specifier and any
+                         surrounding literal text up to the next specifier
+                         are omitted — missing fields never leave gaps.
+
+                         `%c` only renders in priority view (where
+                         `show_category` is true). In category view it is
+                         always omitted regardless of the format string.
+
+                         Examples: >lua
+                             vim.g.pending = { eol_format = '%d  %r' }
+                             vim.g.pending = { eol_format = '%d | %r' }
+                             vim.g.pending = { eol_format = '%c  %d  %r' }
+<
+
     {input_date_formats} (string[], default: {})         *pending-input-formats*
                          List of strftime-like format strings tried in order
                          when parsing a `due:` token that does not match the