Print var from its token, now that JDK 27 gives it a type node

JDK 27 (JDK-8268850) gives a variable declared with `var` a VarTypeTree as
its type, where earlier JDKs have none. This visitor compiles against JDK 21
and has no visitVarType, so it scanned the new node to nothing and every
`var` declaration failed on JDK 27: six golden files in CI, among them
FlexibleConstructor, I959 and B380299722.

declareOne now looks for the `var` token before the type node, the same
reordering google-java-format made in google/google-java-format@075e025c94.
A binding pattern such as `Nested(var i)` has a method of its own, which
now treats a VAR_TYPE node like the missing type of the older JDKs.

Author: abashev

open-java-format/src/main/java/com/palantir/javaformat/java/JavaInputAstVisitor.java

@@ -3576,15 +3576,17 @@ int declareOne(
                 {
                     builder.open(ZERO);
                     {
-                        if (typeWithDims.isPresent() && typeWithDims.get().node != null) {
+                        // `var` first: from JDK 27 (JDK-8268850) its type is a VarTypeTree rather than null,
+                        // and this visitor, compiled against JDK 21, has no visitVarType to print it.
+                        if (isVar) {
+                            token("var");
+                        } else if (typeWithDims.isPresent() && typeWithDims.get().node != null) {
                             scan(typeWithDims.get().node, null);
                             int totalDims = dims.size();
                             builder.open(plusFour);
                             maybeAddDims(dims);
                             builder.close();
                             baseDims = totalDims - dims.size();
-                        } else if (isVar) {
-                            token("var");
                         } else {
                             scan(type, null);
                         }

open-java-format/src/main/java/com/palantir/javaformat/java/java14/Java14InputAstVisitor.java

@@ -113,12 +113,20 @@ public Void visitBindingPattern(BindingPatternTree node, Void unused) {
         return null;
     }
 
+    /**
+     * Is {@code type} the {@code var} of a binding pattern? Older JDKs leave such a pattern without a type, JDK 27
+     * (JDK-8268850) gives it a VarTypeTree, which does not exist on JDK 21, so it is matched by {@link Tree.Kind} name.
+     */
+    private static boolean isVarType(Tree type) {
+        return type.getKind().name().equals("VAR_TYPE");
+    }
+
     private void visitBindingPattern(ModifiersTree modifiers, Tree type, Name name) {
         builder.open(plusFour);
         if (modifiers != null) {
             builder.addAll(visitModifiers(modifiers, Direction.HORIZONTAL, Optional.empty()));
         }
-        if (type == null) {
+        if (type == null || isVarType(type)) {
             token("var");
         } else {
             scan(type, null);