I wanted to at least give a systematic way to show your given multiset is not a set of hook lengths after my flubbed comment. So: taking the $n$ quotients of a partition gives us a constraint on its possible hook lengths.

In particular, take the set of all hook lengths that are divisible by $n$, and then divide each of them by $n$. This new set of numbers will be the set of hook lengths of the $n$ different partitions that are its $n$-quotients.

If your multiset came from a partition, then together its two 2-quotients would have hook lengths 1,2,2,4,5, which can't be the hook lengths of two partitions.

Alternatively, since 5 of the hook lengths were divisible by 2, together the two 2-quotients will be a partition of 5, and when translated back to the original partition will account for 10 of the 12. Therefore, the 2-core must have had size 2. But the 2-cores are exactly the staircase positions, and so 2 isn't a 2-core.

I wish I had a good source for explaining cores and quotients. I think of them by translating through the Maya diagrams , as in Figure 5 on Page 49 of this paper.
Maybe The description here helps, too.

As far as an algorithm to construct the possible partitions with a given hook length set thinking in terms of Maya diagrams and possibly cores and quotients could possibly provide a useful way to control the searching and branching.

I can imagine an algorithm that starts by immediately taking just the even hook lengths and dividing them all by 2, to find the hook-lengths of the 2-quotients. Then we can find the 2-core if it exists. There would now be a lot of branching: we have to distribute the hook-lengths of the 2-quotients over all possible splittings. But once we've chosen a splitting, we can recursively call our program again on the 2-quotients, which will be much smaller partitions.

When it reaches the end, you then have to glue the original partition back together from the core and quotient and check whether the parition has the right hook lengths -- this seems quite expensive.

I make no claims that this algorithm is any good -- I don't know whether the division helps compared to the branching. But as someone who hasn't programmed much the recursion seems relatively easy to code.