fix(dev): repair hunk jump, F4 hook leak, async clone, and nil guards

- vc-config: C-; v d matched literal +/- source text via consult-line, not gutter hunks. It now completes over git-gutter's hunk list and jumps to the chosen line.
- vc-config: clipboard clone ran git synchronously, freezing every frame for the whole clone. It now runs async with a sentinel that opens the clone on success and surfaces the process buffer on failure.
- vc-config: magit-blame bound D and S to the same command. D is now difftastic-magit-diff, matching the transient.
- vc-config: dropped the :commands autoload for git-timemachine-show-selected-revision, a function the package never defined. The phantom appeared in M-x and errored.
- dev-fkeys: both F4 chained-compile handlers armed a hook on the global compilation-finish-functions before their compile ran, so a quit left it live and the next unrelated compile fired the chain. The one-shot hook now installs buffer-locally in the compilation buffer, same shape as the projectile cache-revert hooks.
- test-runner: outside a project with no global test directory, three commands crashed with wrong-type-argument on a nil path. Discovery now returns nil and the commands signal user-error.
- diff-config: removed the global "-w" ediff default, which made every session ignore whitespace (indentation-only changes compared as identical). Whitespace-ignore stays available as ediff's per-session toggle.
- restclient-config: the C-; R bindings went through raw global-set-key, silently depending on keybindings.el loading first. They now use a prefix keymap registered like the other C-; prefixes.
- httpd-config: simple-httpd loaded on a 1s timer and created www/ on every startup. It now defers until impatient-mode needs it, and the doc root is created at package load.

1 files changed, 63 insertions, 31 deletions

diff --git a/tests/test-dev-fkeys--f4-clean-rebuild-impl.el b/tests/test-dev-fkeys--f4-clean-rebuild-impl.el
index 27c7c56a..bed51d79 100644
--- a/tests/test-dev-fkeys--f4-clean-rebuild-impl.el
+++ b/tests/test-dev-fkeys--f4-clean-rebuild-impl.el
@@ -3,7 +3,11 @@
 ;;; Commentary:
 ;; Tests for the "Clean + Rebuild" action handler. Runs the heuristic clean
 ;; command via `compile' from the project root, then chains
-;; `projectile-compile-project' on success via the one-shot finish hook.
+;; `projectile-compile-project' on success via a one-shot finish hook
+;; installed buffer-locally in the compilation buffer `compile' returns.
+;; The global `compilation-finish-functions' is never touched, so a quit
+;; before the compile starts or an unrelated concurrent compile can never
+;; fire the chained rebuild.
 
 ;;; Code:
 
@@ -24,6 +28,18 @@ Bind the dir path to ROOT in BODY. Cleans up on exit."
            ,@body)
        (delete-directory root t))))
 
+(defmacro test-dev-fkeys-cr--with-compilation-buffer (buf &rest body)
+  "Run BODY with BUF bound to a temp buffer standing in for a compilation buffer."
+  (declare (indent 1))
+  `(let ((,buf (generate-new-buffer " *test-compilation*")))
+     (unwind-protect
+         (progn ,@body)
+       (kill-buffer ,buf))))
+
+(defun test-dev-fkeys-cr--local-hooks (buf)
+  "Return the buffer-local finish hooks of BUF, without the t marker."
+  (remq t (buffer-local-value 'compilation-finish-functions buf)))
+
 ;;; Normal Cases
 
 (ert-deftest test-dev-fkeys-clean-rebuild-impl-runs-derived-clean-cmd ()
@@ -34,48 +50,50 @@ Components integrated:
 - `cj/--f4-clean-rebuild-impl' (unit under test)
 - `cj/--f4-derive-clean-cmd' (real)
 - `compile' (MOCKED — captures the command string)
-- `projectile-compile-project' (MOCKED — no-op)
-- `compilation-finish-functions' (real, scoped via let)"
+- `projectile-compile-project' (MOCKED — no-op)"
   (test-dev-fkeys-cr--with-project '("Makefile")
-    (let ((compile-calls nil)
-          (compilation-finish-functions nil))
+    (let ((compile-calls nil))
       (cl-letf (((symbol-function 'compile)
-                 (lambda (cmd) (push cmd compile-calls)))
+                 (lambda (cmd) (push cmd compile-calls) nil))
                 ((symbol-function 'projectile-compile-project)
                  (lambda (_arg) nil)))
         (cj/--f4-clean-rebuild-impl root)
         (should (equal compile-calls '("make clean")))))))
 
-(ert-deftest test-dev-fkeys-clean-rebuild-impl-installs-finish-hook ()
-  "Normal: handler installs exactly one hook in `compilation-finish-functions'."
+(ert-deftest test-dev-fkeys-clean-rebuild-impl-installs-hook-in-compilation-buffer ()
+  "Normal: the one-shot hook lands buffer-locally in the buffer `compile'
+returns; the global `compilation-finish-functions' stays untouched."
   (test-dev-fkeys-cr--with-project '("go.mod")
-    (let ((compilation-finish-functions nil))
-      (cl-letf (((symbol-function 'compile) (lambda (_cmd) nil))
-                ((symbol-function 'projectile-compile-project)
-                 (lambda (_arg) nil)))
-        (cj/--f4-clean-rebuild-impl root)
-        (should (= (length compilation-finish-functions) 1))))))
+    (test-dev-fkeys-cr--with-compilation-buffer buf
+      (let ((compilation-finish-functions nil))
+        (cl-letf (((symbol-function 'compile) (lambda (_cmd) buf))
+                  ((symbol-function 'projectile-compile-project)
+                   (lambda (_arg) nil)))
+          (cj/--f4-clean-rebuild-impl root)
+          (should (null compilation-finish-functions))
+          (should (= 1 (length (test-dev-fkeys-cr--local-hooks buf)))))))))
 
 (ert-deftest test-dev-fkeys-clean-rebuild-impl-hook-runs-projectile-compile-on-success ()
-  "Normal: when the clean step finishes successfully, the installed hook
+  "Normal: when the clean step finishes successfully, the buffer-local hook
 calls `projectile-compile-project' to do the rebuild."
   (test-dev-fkeys-cr--with-project '("Cargo.toml")
-    (let ((compile-calls 0)
-          (compilation-finish-functions nil))
-      (cl-letf (((symbol-function 'compile) (lambda (_cmd) nil))
-                ((symbol-function 'projectile-compile-project)
-                 (lambda (_arg) (cl-incf compile-calls))))
-        (cj/--f4-clean-rebuild-impl root)
-        (run-hook-with-args 'compilation-finish-functions nil "finished\n")
-        (should (= compile-calls 1))))))
+    (test-dev-fkeys-cr--with-compilation-buffer buf
+      (let ((compile-calls 0)
+            (compilation-finish-functions nil))
+        (cl-letf (((symbol-function 'compile) (lambda (_cmd) buf))
+                  ((symbol-function 'projectile-compile-project)
+                   (lambda (_arg) (cl-incf compile-calls))))
+          (cj/--f4-clean-rebuild-impl root)
+          (with-current-buffer buf
+            (run-hook-with-args 'compilation-finish-functions buf "finished\n"))
+          (should (= compile-calls 1)))))))
 
 (ert-deftest test-dev-fkeys-clean-rebuild-impl-runs-clean-from-project-root ()
   "Normal: the clean compile runs with default-directory bound to ROOT."
   (test-dev-fkeys-cr--with-project '("Eask")
-    (let ((seen-dir nil)
-          (compilation-finish-functions nil))
+    (let ((seen-dir nil))
       (cl-letf (((symbol-function 'compile)
-                 (lambda (_cmd) (setq seen-dir default-directory)))
+                 (lambda (_cmd) (setq seen-dir default-directory) nil))
                 ((symbol-function 'projectile-compile-project)
                  (lambda (_arg) nil)))
         (cj/--f4-clean-rebuild-impl root)
@@ -87,14 +105,28 @@ calls `projectile-compile-project' to do the rebuild."
 (ert-deftest test-dev-fkeys-clean-rebuild-impl-hook-skips-rebuild-on-failure ()
   "Boundary: when the clean step fails, projectile-compile-project does not run."
   (test-dev-fkeys-cr--with-project '("Makefile")
-    (let ((compile-calls 0)
-          (compilation-finish-functions nil))
+    (test-dev-fkeys-cr--with-compilation-buffer buf
+      (let ((compile-calls 0)
+            (compilation-finish-functions nil))
+        (cl-letf (((symbol-function 'compile) (lambda (_cmd) buf))
+                  ((symbol-function 'projectile-compile-project)
+                   (lambda (_arg) (cl-incf compile-calls))))
+          (cj/--f4-clean-rebuild-impl root)
+          (with-current-buffer buf
+            (run-hook-with-args 'compilation-finish-functions
+                                buf "exited abnormally\n"))
+          (should (= compile-calls 0)))))))
+
+(ert-deftest test-dev-fkeys-clean-rebuild-impl-dead-compile-buffer-no-global-hook ()
+  "Boundary: when `compile' returns no live buffer, nothing is installed
+anywhere — the global hook list stays empty."
+  (test-dev-fkeys-cr--with-project '("Makefile")
+    (let ((compilation-finish-functions nil))
       (cl-letf (((symbol-function 'compile) (lambda (_cmd) nil))
                 ((symbol-function 'projectile-compile-project)
-                 (lambda (_arg) (cl-incf compile-calls))))
+                 (lambda (_arg) nil)))
         (cj/--f4-clean-rebuild-impl root)
-        (run-hook-with-args 'compilation-finish-functions nil "exited abnormally\n")
-        (should (= compile-calls 0))))))
+        (should (null compilation-finish-functions))))))
 
 ;;; Error Cases