@matrix, $matrix[0] and $matrix. The first two are related. The third is unrelated.
The first one is an array. The second one is an element of an array and the third one is an unrelated
scalar. If you declare an array such as @matrix you can automatically use $matrix[0] to access
the first element, but if you'd also like to use $matrix you'd need to declare that separately.

That leads us to warning. While Perl is OK with you having the exact same variable name for an array and for
a scalar, it is strongly recommended you don't have them in the same code. It can just confuse the reader.

After this short detour, let's go back to our example:

Matrix

The first line prints ARRAY(0x814dd90). As I mentioned, Perl does not have multi-dimensional arrays.
What you see here is that the first element of the @matrix array is a reference to an internal,
so-called anonymous array that holds the actual values. The ARRAY(0x814dd90) is the address of that
internal address in the memory. You can't do much with this, except of knowing that you probably need to
"de-reference" that address. In our case that de-referencing is done by the addition of another
pair of square brackets.

That way you can get back the original values we put in the array.

Visualizing a multi-dimensional array

There is a module called Data::Dumper, which comes with Perl and that can provide
a reasonably readable view of the matrix we created. In order to use it, you first
need to load it to memory with the use statement.
Then calling the Dumper function and passing a reference to it. The
back-slash \, just before the @matrix, creates a reference to the array.
The Dumper function serializes the data structure and returns a string, which is
then printed by the print function.

use Data::Dumper qw(Dumper);
print Dumper \@matrix;

The output will look like this:

$VAR1 = [
[
'zero-zero'
],
[
undef,
'one-one',
'one-two'
]
];

The $VAR1 at the beginning is just a standard name Data::Dumper uses. You can disregard it for now.
the rest of the output shows 3 pairs of square brackets. The outermost pair represents the main array we call
@matrix. the first internal pair holds a single value (zero-zero). This represents the first row in the matrix.
The second internal pair has 3 values. The first one is undef,
this is the place of $matrix[1][0] where we have not assigned a value. The other two we assigned.

Two dimensional array or what?

As you can see this resembles a two dimensional array, but its shape is not rectangular, as you
would expect from a matrix. The first row has only one element while the second row has 3. (even if one of them is undef).

In a similar way there could be elements in the @matrix array that have not other dimension. For example
we could write:

$matrix[2] = 'two';

which would change the output of Data::Dumper to this:

$VAR1 = [
[
'zero-zero'
],
[
undef,
'one-one',
'one-two'
],
'two'
];

Here the outer array has 3 elements. The first two are the internal arrays, and the 3rd one is
a simple scalar.

Look, the second internal array now has a 4th element and that element itself, is an array
(or rather a reference to an array).

Conclusion

An array in Perl can have any number of "dimensions" and it does not need to form a "regular" shape.
Each element can have an internal array. And each element of the internal array can have its own
internal array and so on.