Since it looks like no one else has tried programmatic search I thought I'd give it a try.

I wrote the following Haskell program which generates polyplets of size n and checks them for vanishing cases.  Currently it ignores the symmetries of possible solutions.

<!-- language-all: lang-hs -->

    data Polyplet = Polyplet {
     members :: [(Int,Int)]
    }
    
    instance Eq Polyplet where
     (Polyplet a) == (Polyplet b) = filter(`notElem`a)b ++ filter(`notElem`b)a == []
     
    (Polyplet a) ! (Polyplet b) = filter(`notElem`a)b ++ filter(`notElem`b)a == []
    
    instance Show Polyplet where
     show (Polyplet p) = unlines [[if elem (x,y) p then '*' else ' '|x<-rangify[x|(x,_)<-p]]|y<-rangify[y|(_,y)<-p]]
    
    children :: Polyplet -> [Polyplet]
    children polyplet@(Polyplet p) = [zero $ Polyplet $ c : p | c <- uniquify $ allDeads polyplet] 
    
    zero :: Polyplet -> Polyplet
    zero (Polyplet p) = do
     let mx = minimum [x|(x,_)<-p];
     let my = minimum [y|(_,y)<-p];
     Polyplet[(x-mx,y-my)|(x,y)<-p];
    
    rangify l = [minimum l..maximum l]
    
    deadsAt :: Polyplet -> (Int,Int) -> [(Int,Int)]
    deadsAt (Polyplet p) x = filter(`notElem`p) $ adjacents x 
    
    allDeads :: Polyplet -> [(Int,Int)]
    allDeads polyplet@(Polyplet p) = uniquify $ p >>= deadsAt polyplet
    
    uniquify :: (Eq a) => [a] -> [a]
    uniquify u = [a|(a,b) <- zip u [0..],notElem a $ take b u]
    
    adjacents :: (Int,Int) -> [(Int,Int)]
    adjacents (a,b) = [(a+x,b+y)|x<-[-1..1],y<-[-1..1],(x,y)/=(0,0)]
    
    sizeNpolyplets :: Int -> [Polyplet]
    sizeNpolyplets 1 = [Polyplet [(0,0)]]
    sizeNpolyplets n = uniquify $ sizeNpolyplets (n-1) >>= children
    
    vanishing :: Polyplet -> Bool
    vanishing polyplet@(Polyplet p) = all ((`notElem`[5,6]).length.deadsAt polyplet) p && all ((/=5).length.deadsAt polyplet) (allDeads polyplet)


[Try it online!](https://tio.run/##pVRNj5swEL37V0yl1cY0wCaH9JAm0bbqHnpoValHhLImcYK7xrBAupDS356OScAEur30EMWej/dm3owJWfbEpTydtixn8C2WZSJ5Dktz/EUg4lHA0wzmc/DoZ5Xb@LN88psQobKcqQ2Hh2eT8RLylBOgrYFZsFx27gHeYSdkzlP6qOL8QfLokVkBjMcDc2Axnez5BMgV4pv/BjTVfw/jl0H9mTYajkRzHJQUimfgeWIHHOGAFnZpQQJ5yBWM3o7QmnEYwagqFk7K1F7sSq@oMGxtLZzE96vS2MuKrjG9thOyCYXcpgiDOre0zgq85uKbkORiuu8V6B15GsONyb@BDcyxvgr/Fw42IJ4PSI12JuUnzrZZi@UDIXV6j785n509wm1MQF@iAi@RUCI6RNBt@P3FX3b9ncbR3yB6tHAi1NOJSquqhT0HkIteIHWHDYh03YgV5yOqt9W9fMj7xbf7WivZ2d4m/qqf4i97hGYUa/uDbbjKMwwhpJWuP6kO/kDe@8EutaNIYLVCKS8VNQmEtCHIQ/GJ6YeELMyvyZhvAg5aGVZRZuNbwDkfRYI2b@K6vn1pBBgy5eyJQwAHFMy0pNFfk8lEnbGRhrJxYQdjnBGuuOdMXXfq26U51pO7W9KJPUEAkokj/9r0VJMhcm@vezFTTdOq5Z2RBlHqWsSelypnatW6No@GkJ9MiSwUat8f3Mc4lh3vayPDmQI1m@HN7He@5Uqu9nno9senvwq3t5ecu@XsH4F0sCzWKWJCNxix5MsaklQo/ZbPuwmm0kHbs9Mf "Haskell – Try It Online")

You can envoke it like so in ghci

    mapM_ print $ filter vanishing $ sizeNpolyplets 7

This will make a nice little ascii diagram of the found polyplets.  If you want the raw data you can use

    mapM_ (print.members) $ filter vanishing $ sizeNpolyplets 7

instead.

The program is not very fast but I have been able to confirm that there are no solutions of size $2\leq n\leq 7$ using my laptop.  Perhaps better techniques/more powerful computers can exhaust larger cases.