To guarantee list values are deduped one option is to use a MapSet as collector, or just add Enum.uniq/1 to previous solution.

list
|> Enum.reduce(%{}, fn [k, v], m -> Map.update(m, k, MapSet.new([v]), &MapSet.put(&1, v)) end)
|> Enum.map(fn {k, v} -> [k | Enum.to_list(v)] end)

Whenever I need to check for key unicity, I would use a map. I would also use Enum.reduce… with some translation due to atom key. The last command line transform the map back to a list.

iex> list 
|> Enum.reduce(%{}, fn [k, v], acc -> Map.update(acc, String.to_atom(k), [v], fn y -> [v | y] end) end) 
|> Enum.map(fn {k, v} -> [to_string(k) | v] end)
[["Mark", "Shirt"], ["Tony", "Hat", "Glove"]]

You might need to reverse some order, as I always add to the head of a list [h | t]

In fact, I don’t even need to transform the keys…

iex> list 
|> Enum.reduce(%{}, fn [k, v], acc -> Map.update(acc, k, [v], fn y -> [v | y] end) end) 
|> Enum.map(fn {k, v} -> [k | v] end)

That is true, your solution is nicer with the use of MapSet

That is more complex.

A hint would be to get all root keys, by filtering the keys that does not exists in the list of values.

values = list2 |> Enum.map(& List.last(&1))
root_keys = list2 |> Enum.map(& List.first(&1)) |> Enum.filter(& !Enum.member?(values, &1)) |> Enum.uniq

Then, in some loop, treat the root keys as is, and the others as belonging to a sub tree.

Not to mention edge case like this…

[“Mark”, “Wallet”], [“Tony”, “Wallet”]