make paren stripping work good (#787)

* Revert "Revert "test""

This reverts commit f54d5af.

* bees

* bees

* Re-add paren unwrapping logic lost during rebase

The code that calls unwrap_single_arg_paren was lost during the rebase
onto trunk. This restores the logic that unwraps simple parenthesized
expressions in method arguments (e.g., `foo (1)` -> `foo(1)`) while
preserving parens around keyword expressions that would cause syntax
errors (e.g., `foo (a if b)` -> `foo((a if b))`).

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* Add recursive unwrapping of nested redundant parentheses

When a method call has nested parentheses like `foo ((1))` or
`foo (((1)))`, we now recursively unwrap all levels to produce
`foo(1)`. Inner parens are still preserved when they contain
keyword expressions that would cause syntax errors.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* Fix clippy collapsible_if warning

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* Add ParenExprClose token to prevent blank lines before closing paren

Introduces a new token type specifically for closing multiline
parenthesized expressions. This prevents the render queue from
inserting a blank line between `end` and `)` in constructs like
`foo((case x when 1 then :one end))`.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: fables-tales

fixtures/small/paren_expr_calls_expected.rb

@@ -1,4 +1,4 @@
-a((1))
+a(1)
 other_cool_method((a + b).round(4))
 
 # rubocop:disable PrisonGuard/PrivateModule

fixtures/small/paren_expr_nested_actual.rb

@@ -0,0 +1,17 @@
+# Test cases for nested redundant parentheses
+# Multiple levels of unnecessary parens should be stripped
+
+# Double nested
+foo ((1))
+bar ((a + b))
+
+# Triple nested
+foo (((1)))
+bar (((x)))
+
+# Mixed with method chains
+foo ((bar.baz))
+
+# Nested but inner contains keyword - should preserve inner parens
+foo ((a if b))
+bar ((x rescue y))

fixtures/small/paren_expr_nested_expected.rb

@@ -0,0 +1,17 @@
+# Test cases for nested redundant parentheses
+# Multiple levels of unnecessary parens should be stripped
+
+# Double nested
+foo(1)
+bar(a + b)
+
+# Triple nested
+foo(1)
+bar(x)
+
+# Mixed with method chains
+foo(bar.baz)
+
+# Nested but inner contains keyword - should preserve inner parens
+foo((a if b))
+bar((x rescue y))

fixtures/small/paren_expr_preserve_actual.rb

@@ -0,0 +1,42 @@
+# Test cases for parentheses that MUST be preserved to maintain correct semantics
+# These contain Ruby keywords that would cause syntax errors if parens were removed
+
+# Modifier if - `foo (a if b)` must become `foo((a if b))` not `foo(a if b)` (syntax error)
+foo (a if b)
+method_call (value if condition)
+
+# Modifier unless
+foo (a unless b)
+method_call (value unless condition)
+
+# Modifier while
+foo (a while b)
+
+# Modifier until
+foo (a until b)
+
+# Inline rescue - `foo (x rescue y)` must become `foo((x rescue y))`
+foo (risky_call rescue fallback)
+method_call (might_fail rescue nil)
+
+# `and` keyword (low precedence) - `foo (a and b)` must become `foo((a and b))`
+foo (a and b)
+check (condition and action)
+
+# `or` keyword (low precedence) - `foo (a or b)` must become `foo((a or b))`
+foo (a or b)
+provide (default or fallback)
+
+# case expressions
+foo (case x
+when 1 then :one
+when 2 then :two
+else :other
+end)
+
+# begin/end blocks
+foo (begin
+  risky_operation
+rescue
+  fallback
+end)

fixtures/small/paren_expr_preserve_expected.rb

@@ -0,0 +1,53 @@
+# Test cases for parentheses that MUST be preserved to maintain correct semantics
+# These contain Ruby keywords that would cause syntax errors if parens were removed
+
+# Modifier if - `foo (a if b)` must become `foo((a if b))` not `foo(a if b)` (syntax error)
+foo((a if b))
+method_call((value if condition))
+
+# Modifier unless
+foo((a unless b))
+method_call((value unless condition))
+
+# Modifier while
+foo((a while b))
+
+# Modifier until
+foo((a until b))
+
+# Inline rescue - `foo (x rescue y)` must become `foo((x rescue y))`
+foo((risky_call rescue fallback))
+method_call((might_fail rescue nil))
+
+# `and` keyword (low precedence) - `foo (a and b)` must become `foo((a and b))`
+foo((a and b))
+check((condition and action))
+
+# `or` keyword (low precedence) - `foo (a or b)` must become `foo((a or b))`
+foo((a or b))
+provide((default or fallback))
+
+# case expressions
+foo(
+  (
+    case x
+    when 1
+      :one
+    when 2
+      :two
+    else
+      :other
+    end
+  )
+)
+
+# begin/end blocks
+foo(
+  (
+    begin
+      risky_operation
+    rescue
+      fallback
+    end
+  )
+)

fixtures/small/paren_expr_unwrap_actual.rb

@@ -0,0 +1,39 @@
+# Test cases for parentheses that CAN be safely unwrapped when used as method arguments
+# These are simple expressions where `method (expr)` becomes `method(expr)`
+
+# Simple literals
+foo (1)
+foo ("hello")
+foo (:symbol)
+foo (nil)
+foo (true)
+
+# Simple variables
+foo (bar)
+foo (BAR)
+foo (@bar)
+
+# Simple method calls
+foo (bar.baz)
+
+# Array and hash literals
+foo ([1, 2, 3])
+foo ({a: 1})
+
+# Arithmetic expressions (these bind tighter than method args)
+foo (a + b)
+foo (a * b)
+
+# Comparison expressions
+foo (a == b)
+foo (a < b)
+
+# Logical operators (high precedence &&, ||)
+foo (a && b)
+foo (a || b)
+
+# Range expressions
+foo (1..10)
+
+# Ternary without keywords
+foo (condition ? a : b)

fixtures/small/paren_expr_unwrap_expected.rb

@@ -0,0 +1,39 @@
+# Test cases for parentheses that CAN be safely unwrapped when used as method arguments
+# These are simple expressions where `method (expr)` becomes `method(expr)`
+
+# Simple literals
+foo(1)
+foo("hello")
+foo(:symbol)
+foo(nil)
+foo(true)
+
+# Simple variables
+foo(bar)
+foo(BAR)
+foo(@bar)
+
+# Simple method calls
+foo(bar.baz)
+
+# Array and hash literals
+foo([1, 2, 3])
+foo({a: 1})
+
+# Arithmetic expressions (these bind tighter than method args)
+foo(a + b)
+foo(a * b)
+
+# Comparison expressions
+foo(a == b)
+foo(a < b)
+
+# Logical operators (high precedence &&, ||)
+foo(a && b)
+foo(a || b)
+
+# Range expressions
+foo(1..10)
+
+# Ternary without keywords
+foo(condition ? a : b)