Migration : reecrire aussi les chemins sous leur forme JSON echappee

Trouve en rejouant la migration dans un bac a sable isole. Les fichiers
JSON du dossier de donnees (model_dirs.json, mcp.json, webprefs.json) sont
ecrits par json.Marshal : sous Windows chaque antislash y est DOUBLE. La
reecriture ne cherchait que la forme native et la forme a slashs, elle
laissait donc ces fichiers pointer vers l'ancien dossier.

Pire, la fonction d'echappement etait ecrite avec des litteraux bruts et
remplacait en fait un antislash par lui-meme : elle ne doublait rien. Le
remplacement natif matchait alors la forme JSON et produisait un fichier
invalide (« invalid character 'U' in string escape code »), c'est-a-dire la
liste des dossiers de modeles perdue. Un bug pire que celui qu'on corrigeait.

jsonEscapePath utilise desormais des litteraux entre guillemets, avec un
commentaire explicite sur le piege ("\\" est UN antislash, "\\\\" en fait
deux). Test dedie qui verifie que le chemin est bien reecrit ET que le JSON
reste analysable apres coup.

Verifie en bac a sable sur les trois ecritures simultanement (native,
slashs, JSON echappe) : les trois sont reecrites, le JSON se reparse et
pointe sur le nouveau dossier.

internal/ajean/sys_migrate_test.go

@@ -1,6 +1,7 @@
 package ajean
 
 import (
+	"encoding/json"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -172,3 +173,46 @@ func TestMigrateHomeAdoptsServiceStateFiles(t *testing.T) {
 		t.Fatalf("PID perdu: %q", b)
 	}
 }
+
+// Les fichiers JSON (model_dirs.json, mcp.json, webprefs.json) sont ecrits par
+// json.Marshal : sous Windows chaque antislash y est DOUBLE. Chercher la forme
+// native ne les trouve donc pas, et on croirait avoir tout reecrit en laissant
+// des references mortes. Constate en bac a sable.
+func TestMigrateHomeRewritesJSONEscapedPaths(t *testing.T) {
+	if runtime.GOOS != "windows" {
+		t.Skip("l'echappement JSON des separateurs ne concerne que Windows")
+	}
+	root := t.TempDir()
+	legacy := filepath.Join(root, "jean")
+	target := filepath.Join(root, "ajean")
+	mkHome(t, legacy)
+
+	esc := jsonEscapePath
+	body := `{"dirs":["` + esc(filepath.Join(legacy, "models")) + `"]}`
+	if err := os.WriteFile(filepath.Join(legacy, "model_dirs.json"), []byte(body), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	migrateHome(target, legacy)
+
+	b, err := os.ReadFile(filepath.Join(target, "model_dirs.json"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(string(b), esc(legacy)) {
+		t.Errorf("reference JSON a l'ancien dossier non reecrite:\n%s", b)
+	}
+	if !strings.Contains(string(b), esc(target)) {
+		t.Errorf("le JSON ne pointe pas vers le nouveau dossier:\n%s", b)
+	}
+	// Le fichier doit rester du JSON valide apres reecriture.
+	var parsed struct {
+		Dirs []string `json:"dirs"`
+	}
+	if err := json.Unmarshal(b, &parsed); err != nil {
+		t.Fatalf("JSON casse par la reecriture: %v\n%s", err, b)
+	}
+	if len(parsed.Dirs) != 1 || !strings.HasPrefix(parsed.Dirs[0], target) {
+		t.Fatalf("chemin decode inattendu: %+v", parsed.Dirs)
+	}
+}