I do still believe Style/RedundantParentheses can be useful for catching parenthesis around singular logical statements (ex: if (variable.nil?)).

Those are super rare in practice, though, so providing special support for them seems like an overkill to me. Might be best to just implement a custom cop targeting those.

@bbatsov if you check the documentation for Style/RedundantParentheses it shows:

# bad
(x) if ((y.z).nil?)

# good
x if y.z.nil?

so I assume the purpose of this cop is to also eliminate parenthesis around singular statements, even though they are super rare. Despite being rare, I'd like to ensure they don't get into my code, while still allowing parenthesis around compound logical statements.

In all the cases exemplified, Ruby style does not use parentheses around the outermost part of condition. And This cop respects parentheses that alter the precedence of the condition and targets only the outermost parentheses for removal.
Additionally, this rule is also indicated in the Ruby Style Guide, as shown here:
https://rubystyle.guide/#no-parens-around-condition

@koic

In all the cases exemplified, Ruby style does not use parentheses around the outermost part of condition.
Additionally, this rule is also indicated in the Ruby Style Guide, as shown here:
https://rubystyle.guide/#no-parens-around-condition

The rubocop examples show only invole singular logical statements (ex: if (value.nil?)), not compound logical statements (ex: if (foo && (bar || !baz))).

The examples listed in the Ruby Style guide also only use singular logical statements, not compound logical statements. There is no authoritative style example for whether parenthesis in compound logical statements is allowed or prohibited This should be clarified, as currently every example only refers to singular logical statements.

I would like to second this. I've had a couple cases that prompted me to disable this cop entirely because it wanted my code to be less readable. For instance:

@var ||= (method1 || method2)

Ruby does not require the parentheses. However, having the parentheses makes it very clear what is happening in the code. If the parentheses are gone, I expect developers looking at the code later to have to pause and consider if the code actually works the way it is intended.