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, 66 insertions, 35 deletions

diff --git a/tests/test-dev-fkeys--f4-compile-and-run-impl.el b/tests/test-dev-fkeys--f4-compile-and-run-impl.el
index d59a6cd6..34e5bdf3 100644
--- a/tests/test-dev-fkeys--f4-compile-and-run-impl.el
+++ b/tests/test-dev-fkeys--f4-compile-and-run-impl.el
@@ -2,8 +2,11 @@
 
 ;;; Commentary:
 ;; Tests for the "Compile + Run" action handler. After kicking off the
-;; compile, attaches a one-shot `compilation-finish-functions' hook that
-;; runs the project on success.
+;; compile, attaches a one-shot finish hook buffer-locally in the
+;; compilation buffer projectile returns, so the global
+;; `compilation-finish-functions' is never touched.  A quit at
+;; projectile's compile prompt therefore can never leave an armed hook
+;; that a later unrelated compile would fire.
 
 ;;; Code:
 
@@ -12,6 +15,14 @@
 (add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
 (require 'dev-fkeys)
 
+(defmacro test-dev-fkeys-car--with-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))))
+
 ;;; Normal Cases
 
 (ert-deftest test-dev-fkeys-compile-and-run-impl-invokes-projectile-compile ()
@@ -19,57 +30,77 @@
 
 Components integrated:
 - `cj/--f4-compile-and-run-impl' (unit under test)
-- `projectile-compile-project' (MOCKED via cl-letf)
-- `compilation-finish-functions' (real, scoped via let)"
-  (let ((compile-calls 0)
-        (compilation-finish-functions nil))
+- `projectile-compile-project' (MOCKED via cl-letf)"
+  (let ((compile-calls 0))
     (cl-letf (((symbol-function 'projectile-compile-project)
-               (lambda (_arg) (cl-incf compile-calls))))
+               (lambda (_arg) (cl-incf compile-calls) nil)))
       (cj/--f4-compile-and-run-impl)
       (should (= compile-calls 1)))))
 
-(ert-deftest test-dev-fkeys-compile-and-run-impl-installs-finish-hook ()
-  "Normal: handler installs exactly one hook in `compilation-finish-functions'."
-  (let ((compilation-finish-functions nil))
-    (cl-letf (((symbol-function 'projectile-compile-project)
-               (lambda (_arg) nil)))
-      (cj/--f4-compile-and-run-impl)
-      (should (= (length compilation-finish-functions) 1)))))
+(ert-deftest test-dev-fkeys-compile-and-run-impl-installs-hook-in-compilation-buffer ()
+  "Normal: the one-shot hook lands buffer-locally in the compilation buffer;
+the global `compilation-finish-functions' stays untouched."
+  (test-dev-fkeys-car--with-buffer buf
+    (let ((compilation-finish-functions nil))
+      (cl-letf (((symbol-function 'projectile-compile-project)
+                 (lambda (_arg) buf)))
+        (cj/--f4-compile-and-run-impl)
+        (should (null compilation-finish-functions))
+        (should (= 1 (length (remq t (buffer-local-value
+                                      'compilation-finish-functions buf)))))))))
 
 (ert-deftest test-dev-fkeys-compile-and-run-impl-hook-runs-projectile-run-on-success ()
-  "Normal: when the compile finishes successfully, the installed hook calls
-`projectile-run-project'.
+  "Normal: when the compile finishes successfully, the buffer-local hook
+calls `projectile-run-project'.
 
 Components integrated:
 - `cj/--f4-compile-and-run-impl' (unit under test)
-- `projectile-compile-project' (MOCKED — no-op)
+- `projectile-compile-project' (MOCKED — returns the compilation buffer)
 - `projectile-run-project' (MOCKED — counts calls)
-- `compilation-finish-functions' (real)
+- `compilation-finish-functions' (real, buffer-local)
 - `run-hook-with-args' (real — simulates compile.el firing the hook)"
-  (let ((run-calls 0)
-        (compilation-finish-functions nil))
-    (cl-letf (((symbol-function 'projectile-compile-project)
-               (lambda (_arg) nil))
-              ((symbol-function 'projectile-run-project)
-               (lambda (_arg) (cl-incf run-calls))))
-      (cj/--f4-compile-and-run-impl)
-      (run-hook-with-args 'compilation-finish-functions nil "finished\n")
-      (should (= run-calls 1)))))
+  (test-dev-fkeys-car--with-buffer buf
+    (let ((run-calls 0)
+          (compilation-finish-functions nil))
+      (cl-letf (((symbol-function 'projectile-compile-project)
+                 (lambda (_arg) buf))
+                ((symbol-function 'projectile-run-project)
+                 (lambda (_arg) (cl-incf run-calls))))
+        (cj/--f4-compile-and-run-impl)
+        (with-current-buffer buf
+          (run-hook-with-args 'compilation-finish-functions buf "finished\n"))
+        (should (= run-calls 1))))))
 
 ;;; Boundary Cases
 
 (ert-deftest test-dev-fkeys-compile-and-run-impl-hook-skips-projectile-run-on-failure ()
   "Boundary: when the compile fails, projectile-run-project must not run.
 The hook still self-removes (covered in the make-once-hook tests)."
-  (let ((run-calls 0)
-        (compilation-finish-functions nil))
+  (test-dev-fkeys-car--with-buffer buf
+    (let ((run-calls 0)
+          (compilation-finish-functions nil))
+      (cl-letf (((symbol-function 'projectile-compile-project)
+                 (lambda (_arg) buf))
+                ((symbol-function 'projectile-run-project)
+                 (lambda (_arg) (cl-incf run-calls))))
+        (cj/--f4-compile-and-run-impl)
+        (with-current-buffer buf
+          (run-hook-with-args 'compilation-finish-functions
+                              buf "exited abnormally\n"))
+        (should (= run-calls 0))))))
+
+(ert-deftest test-dev-fkeys-compile-and-run-impl-quit-leaves-no-global-hook ()
+  "Boundary: a quit at projectile's prompt leaves no armed hook anywhere.
+This is the regression the buffer-local install exists to prevent: the
+old shape armed a global hook before the prompt, so C-g left it live and
+the next unrelated compile fired the chained run."
+  (let ((compilation-finish-functions nil))
     (cl-letf (((symbol-function 'projectile-compile-project)
-               (lambda (_arg) nil))
-              ((symbol-function 'projectile-run-project)
-               (lambda (_arg) (cl-incf run-calls))))
-      (cj/--f4-compile-and-run-impl)
-      (run-hook-with-args 'compilation-finish-functions nil "exited abnormally\n")
-      (should (= run-calls 0)))))
+               (lambda (_arg) (signal 'quit nil))))
+      (condition-case nil
+          (cj/--f4-compile-and-run-impl)
+        (quit nil))
+      (should (null compilation-finish-functions)))))
 
 (provide 'test-dev-fkeys--f4-compile-and-run-impl)
 ;;; test-dev-fkeys--f4-compile-and-run-impl.el ends here