vfmt: preserve parens around parenthesized function calls

parser fix (fixes #22652) unwraps a ParExpr wrapping a call's left, so
a call like (add)(2, 4) was parsed but vfmt could no longer see the parens
and rewrote it to add(2, 4) — defeating the regression test.

Add is_paren_wrapped_call flag on CallExpr, set by the parser when it
unwraps the ParExpr, and use it in fmt.call_expr to write '(' name ')'.

Author: medvednikov

vlib/v/ast/ast.v

@@ -940,6 +940,7 @@ pub mut:
 	//
 	is_expand_simple_interpolation bool // true, when the function/method is marked as @[expand_simple_interpolation]
 	is_unwrapped_fn_selector       bool // true, when the call is from an unwrapped selector (e.g. if t.foo != none { t.foo() })
+	is_paren_wrapped_call          bool // true, when the callee was wrapped in parentheses: `(f)(x)` — used by vfmt to preserve the parens
 	// Calls to it with an interpolation argument like `b.f('x ${y}')`, will be converted to `b.f('x ')` followed by `b.f(y)`.
 	// The same type, has to support also a .write_decimal(n i64) method.
 }

vlib/v/fmt/fmt.v

@@ -2213,6 +2213,8 @@ pub fn (mut f Fmt) call_expr(node ast.CallExpr) {
 			name := f.short_module(node.name)
 			if node.is_static_method {
 				f.write_static_method(node.name, name)
+			} else if node.is_paren_wrapped_call {
+				f.write('(${name})')
 			} else {
 				f.write(name)
 			}

vlib/v/parser/expr.v

@@ -882,16 +882,17 @@ fn (mut p Parser) call_expr_with_left(left ast.Expr) ast.CallExpr {
 		kind = p.call_kind(fn_name)
 	}
 	return ast.CallExpr{
-		name:           name
-		name_pos:       name_pos
-		mod:            mod
-		kind:           kind
-		left:           unwrapped_left
-		args:           args
-		pos:            pos
-		scope:          p.scope
-		or_block:       or_block
-		is_return_used: p.expecting_value
+		name:                  name
+		name_pos:              name_pos
+		mod:                   mod
+		kind:                  kind
+		left:                  unwrapped_left
+		args:                  args
+		pos:                   pos
+		scope:                 p.scope
+		or_block:              or_block
+		is_return_used:        p.expecting_value
+		is_paren_wrapped_call: left is ast.ParExpr
 	}
 }