refactor(types): extract inline anonymous types into named classes

Problem: several functions used inline `{...}` table types in their
`@param` and `@return` annotations, making them hard to read and
impossible to reference from other modules.

Solution: extract each into a named `---@class`: `pending.Metadata`,
`pending.TaskFields`, `pending.CompletionItem`, `pending.SystemResult`,
and `pending.OAuthClientOpts`.

lua/pending/sync/util.lua

@@ -0,0 +1,79 @@
+local log = require('pending.log')
+
+---@class pending.SystemResult
+---@field code integer
+---@field stdout string
+---@field stderr string
+
+---@class pending.sync.util
+local M = {}
+
+local _sync_in_flight = false
+
+---@param fn fun(): nil
+function M.async(fn)
+  coroutine.resume(coroutine.create(fn))
+end
+
+---@param args string[]
+---@param opts? table
+---@return pending.SystemResult
+function M.system(args, opts)
+  local co = coroutine.running()
+  if not co then
+    return vim.system(args, opts or {}):wait() --[[@as pending.SystemResult]]
+  end
+  vim.system(args, opts or {}, function(result)
+    vim.schedule(function()
+      coroutine.resume(co, result)
+    end)
+  end)
+  return coroutine.yield() --[[@as { code: integer, stdout: string, stderr: string }]]
+end
+
+---@param name string
+---@param fn fun(): nil
+function M.with_guard(name, fn)
+  if _sync_in_flight then
+    log.warn(name .. ': Sync already in progress — please wait.')
+    return
+  end
+  _sync_in_flight = true
+  local ok, err = pcall(fn)
+  _sync_in_flight = false
+  if not ok then
+    log.error(name .. ': ' .. tostring(err))
+  end
+end
+
+---@return boolean
+function M.sync_in_flight()
+  return _sync_in_flight
+end
+
+---@param s pending.Store
+function M.finish(s)
+  s:save()
+  require('pending')._recompute_counts()
+  local buffer = require('pending.buffer')
+  if buffer.bufnr() and vim.api.nvim_buf_is_valid(buffer.bufnr()) then
+    buffer.render(buffer.bufnr())
+  end
+end
+
+---@param parts [integer, string][]
+---@return string
+function M.fmt_counts(parts)
+  local items = {}
+  for _, p in ipairs(parts) do
+    if p[1] > 0 then
+      table.insert(items, p[1] .. ' ' .. p[2])
+    end
+  end
+  if #items == 0 then
+    return 'nothing to do'
+  end
+  return table.concat(items, ' | ')
+end
+
+return M