feat(ftp): add FTP/FTPS adapter via curl (#167)

* feat(ftp): add FTP/FTPS adapter via curl

Problem: canola has no way to browse or edit files on FTP servers,
despite the adapter system being designed for exactly this pattern.
curl speaks FTP natively, including FTPS (FTP over TLS), and requires
no new dependencies.

Solution: implement `lua/oil/adapters/ftp.lua` with `oil-ftp://` and
`oil-ftps://` schemes. Parses Unix and IIS LIST output, supports
`size`, `mtime`, and `permissions` columns, and implements the full
adapter API (list, read_file, write_file, render_action, perform_action).
Same-host renames use RNFR/RNTO; cross-host and local↔FTP copies use
curl download/upload through a tmpfile. Adds `extra_curl_args` config
option and documents the adapter in `doc/oil.txt`.

Based on: stevearc/oil.nvim#210

* docs(upstream): mark #210 fixed in #167

* fix(ftp): use python3 ftplib for control-channel FTP operations

Problem: DELE, RMD, MKD, and RNFR/RNTO were implemented using
curl --quote, which requires a subsequent LIST or STOR to trigger
the FTP connection. That data-channel operation hangs on slow or
busy servers, making every mutation appear stuck.

Solution: replace the curl --quote approach with a python3 ftplib
one-liner for all control-channel operations. ftplib executes DELE,
RMD, MKD, RNFR/RNTO, and SITE CHMOD without opening a data channel,
so they complete instantly. The curl wrapper is retained for LIST,
read_file, and write_file, which genuinely need a data channel.

* fix(ftp): use nil entry ID so cache assigns unique IDs

Problem: `M.list` returned entries as `{0, name, type, meta}`.
`cache.store_entry` only assigns a fresh ID when `entry[FIELD_ID] == nil`;
passing 0 caused every entry to be stored as ID 0, all overwriting
each other. `get_entry_by_id(0)` then always returned the last-stored
entry, breaking navigation (always opened the same file), rename
(wrong entry matched), and create (wrong diff).

Solution: change the placeholder from 0 to nil, matching how
`cache.create_entry` itself builds entries.

* fix(ftp): use ftp.rename() for RNFR/RNTO and raw Python lines in ftpcmd

Problem: `ftpcmd` wrapped every command in `ftp.voidcmd()`, which
expects a final 2xx response. `RNFR` returns 350 (intermediate),
so `voidcmd` raised an exception before `RNTO` was ever sent,
causing every rename to fail with '350 Ready for destination name'.

Solution: change `ftpcmd` to accept raw Python lines instead of FTP
command strings, then use `ftp.rename(src, dst)` for the rename case.
`ftplib.rename` handles the 350 intermediate response correctly
internally. All other callers now wrap their FTP commands in
`ftp.voidcmd()` explicitly.

* fix(ftp): recursively delete directory contents before RMD

Problem: FTP's RMD command fails with '550 Directory not empty'
if the directory has any contents. Unlike the S3 adapter which uses
`aws s3 rm --recursive`, FTP has no protocol-level recursive delete.

Solution: emit a Python rmtree helper inside the ftpcmd script that
walks the directory via MLSD, recursively deletes children (DELE for
files, rmtree for subdirs), then sends RMD on the now-empty directory.

* fix(ftp): give oil-ftps:// its own adapter name to prevent scheme clobbering

Problem: both oil-ftp:// and oil-ftps:// mapped to the adapter name
'ftp', so config.adapter_to_scheme['ftp'] was set to whichever scheme
pairs() iterated last — non-deterministic. init.lua uses
adapter_to_scheme[adapter.name] to reconstruct the parent URL, so
roughly half the time it injected 'oil-ftps://' into ftp:// buffer
navigation, causing the ssl-reqd error on '-' press.

Solution: register oil-ftps:// under adapter name 'ftps' via a
one-line shim that returns require('oil.adapters.ftp'). Now
adapter_to_scheme['ftp'] = 'oil-ftp://' and
adapter_to_scheme['ftps'] = 'oil-ftps://' are both stable.

* fix(ftp): percent-encode path in curl FTP URLs

Problem: filenames containing spaces (or other URL-unsafe characters)
caused curl to fail with "Unknown error" because the raw path was
concatenated directly into the FTP URL.

Solution: add `url_encode_path` to encode non-safe characters (excluding
`/`) before building the curl URL in `curl_ftp_url`.

* fix(ftp): fix STARTTLS, error visibility, and robustness

Problem: `curl_ftp_url` emitted `ftps://` (implicit TLS) for
`oil-ftps://` URLs, causing listing to fail against STARTTLS servers
while Python mutations worked — the two paths spoke different TLS
modes. curl's `-s` flag silenced all error output, producing "Unknown
error" on any curl failure. File creation used `/dev/null` (breaks on
Windows, diverges from S3). The Python TLS context didn't honour
`--insecure`/`-k` from `extra_curl_args`. Deleting non-empty dirs on
servers without MLSD gave a cryptic `500 Unknown command`.

Solution: Always emit `ftp://` in `curl_ftp_url`; TLS is enforced
solely via `--ssl-reqd`, making STARTTLS consistent between curl and
Python. Add `-S` to expose curl errors. Replace `/dev/null` with
`curl -T -` + `stdin='null'` (matches `s3fs` pattern). Mirror
`--insecure`/`-k` into the Python SSL context. Wrap `mlsd()` in
try/except with a clear actionable message. Add `spec/ftp_spec.lua`
with 28 unit tests covering URL parsing, list parsing, and curl URL
building. Update `doc/oil.txt` to document STARTTLS and MLSD.

* ci: format

* fix(ftp): resolve LuaLS type warnings in `curl` wrapper and `parse_unix_list_line`

doc/oil.txt

@@ -173,6 +173,8 @@ The full list of options with their defaults:
       extra_scp_args = {},
       -- Extra arguments to pass to aws s3 when creating/deleting/moving/copying files using aws s3
       extra_s3_args = {},
+      -- Extra arguments to pass to curl for FTP operations
+      extra_curl_args = {},
       -- EXPERIMENTAL support for performing file operations with git
       git = {
         -- Return true to automatically git add/mv/rm files
@@ -993,6 +995,53 @@ S3                                                                *oil-adapter-s
     Older versions of Neovim (0.11 and earlier) don't support numbers in the
     URL scheme, so use `oil-sss` instead of `oil-s3`.
 
+FTP                                                              *oil-adapter-ftp*
+
+    Browse files over FTP or FTPS (FTP over TLS). Open a buffer with: >
+        nvim oil-ftp://[username[:password]@]hostname[:port]/[path]/
+        nvim oil-ftps://[username[:password]@]hostname[:port]/[path]/
+<
+    The `oil-ftps://` scheme uses explicit TLS (STARTTLS / AUTH TLS, RFC 4217).
+    The server must support the `AUTH TLS` command on port 21. Servers using
+    implicit TLS (port 990) are not supported. Use `oil-ftp://` for plain FTP.
+
+    Authentication ~
+
+    Credentials can be supplied in the URL (`user:pass@host`) or stored in
+    `~/.netrc` (recommended — keeps passwords out of shell history): >
+        machine ftp.example.com login myuser password mypass
+<
+    How it works ~
+
+    The FTP adapter uses `curl` to perform all operations. Directory listings
+    come from FTP LIST output (Unix and IIS/Windows formats are both supported).
+    File reads download to a local tempfile; file writes upload from a tempfile.
+    Renames on the same server use the FTP RNFR/RNTO commands. File copies
+    between servers go through a local tempfile.
+
+    Limitations ~
+
+    Symbolic links cannot be created over FTP. Directory copies are not
+    supported (copy individual files instead). Moving or copying directories
+    across different FTP hosts is not supported. Deleting non-empty directories
+    requires MLSD support (RFC 3659); supported by vsftpd, ProFTPD, FileZilla
+    Server, and most servers from 2007 onwards.
+
+    Configuration ~
+
+    Pass extra flags to `curl` with `extra_curl_args`: >lua
+        require("oil").setup({
+          extra_curl_args = { "--insecure" },
+        })
+<
+    The adapter supports the `size`, `mtime`, and `permissions` columns.
+    Permission changes use the FTP `SITE CHMOD` command; not all servers
+    support it.
+
+    Dependencies ~
+
+    Requires `curl` (standard on Linux and macOS).
+
 Trash                                                        *oil-adapter-trash*
 
     See |oil-trash| for details on the built-in trash adapter.