Closes the drift flagged in ckeditor-files.md §17 row #10. The v2
decision was to cap reads at 64 MiB with a typed error; the shipped
code never had the cap, so `ck_files::read` would happily allocate a
multi-GB string for a stray log file and OOM the editor on the first
read. An MCP fetch endpoint that eventually rides this primitive has
the same exposure.

The cap is a public const so callers and the design doc can anchor to
it; `read` probes `fs::metadata(path)?.len()` before the `fs::read`
call, so oversized files never allocate a buffer. A new
`FileError::TooLarge { path, size }` variant carries both the
offending path and the observed size so error messages do not have to
re-stat.

New tests in `ck-files/tests/errors.rs`:

- `max_file_size_is_exactly_64_mib` pins the literal constant value
  (67,108,864). Without this, a mutant that turned `64 * 1024 * 1024`
  into `64 + 1024 * 1024` would shrink the cap to ~1 MiB and slip past
  the symbolic at-cap / above-cap tests (both reference
  `MAX_FILE_SIZE` symbolically, so they scale with the mutant).
- `read_file_at_cap_succeeds` / `read_file_above_cap_errors` use
  sparse files (`File::set_len`) so the boundary assertion stays fast
  without writing 64 MiB of real bytes.
- `display_for_too_large_shows_the_path_and_size` and
  `error_source_for_too_large_is_none` round-trip the new variant
  through the Display and Error::source contracts.
- `read_errors_on_a_directory_path` in `tests/read_write.rs` covers
  the `fs::read(path)?` error arm that the happy-path reads don't
  touch (metadata succeeds on a directory, the cap check passes,
  fs::read fails with "is a directory").

Gate status: lint 0/0, `cargo test --workspace` all green,
`cargo llvm-cov --package ck-files` at 100% line / 99.61% region
(up from 99.39%, 2 regions exempt — the two `write_atomic` fsync
error arms that require kernel-level fault injection),
`cargo mutants --package ck-files` at 28/28 caught (100% kill, up
from 95.45%). No baseline movement.

@@ -195,2 +240,4 @@
 /// ```
 pub fn read(path: &Path) -> Result<String, FileError> {
+    let size = fs::metadata(path)?.len();
+    if size > MAX_FILE_SIZE {

@@ -118,0 +166,4 @@
+            assert_eq!(p, path);
+            assert_eq!(size, over);
+        }
+        other => panic!("expected TooLarge, got {other:?}"),

@@ -55,0 +62,4 @@
+fn read_errors_on_a_directory_path() {
+    let fx = Fixture::new();
+    let path = fx.path("a-directory");
+    std::fs::create_dir(&path).unwrap();