Load each spelling that only restated a shorter one, as that shorter form

internal/grammar/template.go

@@ -8,9 +8,6 @@ import (
 
 func IsTemplate(arg string) (bool, error) {
 	if strings.ContainsRune(arg, '{') || (isJSONStart(strings.TrimSpace(arg)) && json.Valid([]byte(arg))) {
-		if path, lone := loneReference(arg); lone {
-			return false, pathAdvice(path, fmt.Sprintf("%s is the path %s written as a template", arg, path))
-		}
 		return true, nil
 	}
 	if i := strings.IndexAny(arg, `}"`); i >= 0 {
@@ -19,60 +16,13 @@ func IsTemplate(arg string) (bool, error) {
 	if strings.HasPrefix(strings.TrimSpace(arg), "[") {
 		return false, fmt.Errorf(`%q starts with "[" and is not valid JSON, so it names no template; a path starts with a name`, arg)
 	}
-	if _, err := SplitPath(arg); err != nil {
-		return false, err
-	}
-	if path := strings.TrimLeft(arg, "/"); path != arg && path != "" {
-		return false, pathAdvice(path, fmt.Sprintf("path %s starts with /, and every path starts at the root already", arg))
-	}
-	return false, nil
+	_, err := SplitPath(CallerPath(arg))
+	return false, err
 }
 
+// CallerPath is a path as a caller passed it, without the slashes it may start with.
+func CallerPath(path string) string { return strings.TrimLeft(path, "/") }
+
 func isJSONStart(arg string) bool {
 	return strings.HasPrefix(arg, "[") || strings.HasPrefix(arg, `"`)
 }
-
-// pathAdvice refuses a spelling of path, naming path to write, or why no name can spell it.
-func pathAdvice(path, refusal string) error {
-	if err := CheckPathIdentifiers(path); err != nil {
-		return err
-	}
-	return fmt.Errorf("%s; write %s", refusal, path)
-}
-
-// loneReference is the path a template spells when the value it holds — a format string, a
-// JSON string, or an object holding only a format — is one reference token and nothing else.
-func loneReference(arg string) (string, bool) {
-	var raw any
-	if json.Unmarshal([]byte(arg), &raw) != nil {
-		raw = arg
-	}
-	if m, isObject := raw.(map[string]any); isObject && len(m) == 1 {
-		raw = m["format"]
-	}
-	format, isString := raw.(string)
-	if !isString {
-		return "", false
-	}
-	toks, err := ParseFormat(format)
-	if err != nil {
-		return "", false
-	}
-	body, lone := loneRef(toks)
-	if !lone {
-		return "", false
-	}
-	if strings.HasPrefix(body, "/") {
-		body = "/" + strings.TrimLeft(body, "/")
-	}
-	_, path, err := RefShape(body)
-	return path, err == nil
-}
-
-// loneRef is the reference a format of one reference token and nothing else reads.
-func loneRef(toks []Token) (string, bool) {
-	if len(toks) != 1 || toks[0].Kind != PathRead || len(toks[0].Arms) != 1 || !IsRef(toks[0].Arms[0]) {
-		return "", false
-	}
-	return toks[0].Arms[0], true
-}