Do the parentheses around $x do anything?

Yes, they make a single-element list.

It seems to me that the rhs will always be a scalar...

It will, because the high-precedence or operator (||) imposes scalar context on its operands and evaluates to a scalar.

Consider, however, the difference between:

my  $x  = @some_array;
my ($y) = @some_array;
[download]

The lvalue parentheses are significant.

It will, because the high-precedence or operator (||) imposes scalar context on its operands and evaluates to a scalar.

Only on the LHS.

use feature qw( say );

my @s = 0 || scalar('a','b','c');
my @l = 0 || ('a','b','c');

say for @s;
say "---";
say for @l;
[download]

c
---
a
b
c
[download]

In this case yes (I was too hasty in my explanation). The operator passes along the context in which it appears to its rhs expression.

(...)=, my(...)=, @a=, %h= and possibly others cause the list assignment operator to be used instead of the scalar assignment operator. I've already written on the differences between the two.

In your specific case, there is no functional difference between my ($x) = and my $x = unless the "..." is nothing. If the "..." is nothing, there could be a difference.

use feature qw( say );

sub wp { my($x) = ($_[0] || 0); }
sub np { my $x  = ($_[0] || 0); }

say wp(3);    # 3
say np(3);    # 3
say 0+wp(3);  # 1
say 0+np(3);  # 3
[download]

Do the parentheses around $x do anything?

It seems to me that the rhs will always be a scalar,

and these are equivalent

my $x = 3 - 1; 
say $x;
[download]

my $y = length "ab";
say $y;
[download]

In your example, in the first case, $x gets the value of the scalar expression on the RHS of the assignment. In the second case, $y is assigned the value of the first element of the list on the RHS of the assignment. There's a difference. Whether you find the difference significant enough to call it not equivalent, or small enough to call it equivalent, I leave up to you. As long as you know what the difference is, it doesn't matter how you label it.

It's one of the few cases where parenthesis actually create a list.

Not directly. The LHS of a list assignment operator is always a list. It doesn't matter whether parens are used or not.

But indirectly, yes, because my ($x) (as opposed to my $x) is what causes the list assignment operator to be used in the first place.

In your example, the round brackets around the $x don't do anything, as the right hand side of the assignment must be in scalar context.

Perhaps the reason you have that code fragment is that it is similar to one popular way of passing function arguments:

sub do_stuff {
    my($x,$y,$z) = @_;
    ...
}
[download]

In one company I worked at, the coding convention extended the idiom to this form (with the comments on each argument.):

sub do_stuff {
    my(
      $x,   # X axis coordinate.
      $y,   # Y axis coordinate.
      $z,   # Z axis coordinate.
    ) = @_;
    ...
}
[download]

in my ($y) = 10; the = is a list assignment which returns the number of assigned elements¹

That's a crucial trick for iterators, where returned elements might be false (like 0 , '' or undef).

So

while ( ($x) = iterator() ) {
...
}
[download]

 
while ( $x = iterator() ) {
...
}
[download]

UPDATE:

1) in scalar context!