Find path in tree structure

I have a PostgreSQL 15 table taxons with this structure:

CREATE TABLE taxons (
    id integer NOT NULL,
    parent_id integer,
    name jsonb
);

INSERT INTO taxons VALUES (1, null, '{ "en": "Clothes", "de": "Bekleidung" }');
INSERT INTO taxons VALUES (2, 1, '{ "en": "Men", "de": "Männer" }');
INSERT INTO taxons VALUES (3, 2, '{ "en": "Pants", "de": "Hosen" }');

I want to find a specific path by name in this structure, e.g. Clothes > Men > Pants. The names could be in any locale of the name field.

This is the query I have so far:

SELECT 
  t0.* 
FROM 
  taxons t0 
  JOIN taxons t1 ON (
    LOWER(t1.name ->> 'en') = LOWER('clothes') OR LOWER(t1.name ->> 'de') = LOWER('clothes')
  ) 
  AND t1.parent_id IS NULL 
  JOIN taxons t2 ON (
    LOWER(t2.name ->> 'en') = LOWER('MEN') OR LOWER(t2.name ->> 'de') = LOWER('MEN')
  ) 
  AND t2.parent_id = t1.id 
WHERE 
  (
    LOWER(t0.name ->> 'en') = LOWER('Hosen') OR LOWER(t0.name ->> 'de') = LOWER('Hosen')
  ) 
  AND t0.parent_id = t2.id

My questions would be:

1. Is there a better way to query the tree structure? I've read something about recursive CTE's, but have a hard time understanding it.
2. Is it possible to use some kind of jsonb function to search within name for a match so that I don't have to know all the locales in my query? Some records can have different locales, and sometimes there are more than 5 translations for a name, so the query get's pretty long and unreadable.

Here is a DB Fiddle https://www.db-fiddle.com/f/b28vZrTpRcX5RbhKm4ZvKo/3

demo: db<>fiddle

WITH RECURSIVE cte AS (                       -- 1
    SELECT *, ARRAY[t.name ->> 'de'] as path  -- 3
    FROM taxons t
    WHERE parent_id IS NULL

    UNION                                     -- 2

    SELECT                                    -- 4
        t.*,
        c.path || (t.name ->> 'de')
    FROM taxons t
    JOIN cte c ON c.id = t.parent_id
)
SELECT 
    array_to_string(c.path, ' -> ') as name   -- 5
FROM cte c

1. Starting a recursive CTE. A recursive CTE always contains two parts. The starting query and the recursion part.
2. Both parts are devided by the UNION clause.
3. This is the start. Here the root record(s) will be found. In your case the root is the record with no parents. Additionally to its columns, I added an array for storing the path. The first element in the path is the current name.
4. Now it works similar to what you did. In the first recursion all records are searched which parent_id values equal the previously found id values (in that case the one of the root record) by doing a JOIN operation. The previous result is always represented by the WITH clause, so the joining table is cte (So, in your case the current step's table is taxons, the one for the previous results is cte). The next recursion will find the elements with the parent_id values equal to the id values of the previous recursion and so on. All found records will be appended to the previous records by the UNION clause. Additionally all found name values will be added to the array, I created in the root step to save the path.
5. Get the entire recursion set afterwards and create the appropriate string from the created path array.