({{Stack+Card, ⟹, NewStacks }, {ReArrangeStacks, ⟹, ListOfStacks}, {DeadStack, ⟹, Deleted}, {Starts for each possible Card, ⟹, Purging Of duplicte Stacks}})

With  0 being blank, 1 being a dot, 3 a circle, and 3+1=4 a circle/dot combo.

Clear[RandomSwishCard]
RandomSwishCard[]:=Module[
{Card},
Card=ConstantArray[0,{4,3}];
{n1,n2}=RandomSample[Range[0,11],2];
{i,j}=QuotientRemainder[n1,3]+1;
Card[[i,j]]=1;
{i,j}=QuotientRemainder[n2,3]+1;
Card[[i,j]]=3;
Card
]

Card=RandomSwishCard[];
Deck=Union[Table[ RandomSwishCard[],{3}]]

A valid stack has:  one dot, one circle, and a number of filled circles, With our encoding this is a single “1”, a single “2”, and a number of “3”s and “0”s and nothing else.  First we need a way to test if something is a swish or could be going to become a swish.

SwishTest[TestStack_]:= Module[
{FlatStack=Normal[Flatten[TestStack]]},
{ZeroCount,OneCount,ThreeCount,FourCount}=Map[Count[FlatStack,#]&, {0,1,3,4}];
OtherCount=12-(ZeroCount+OneCount+ThreeCount+FourCount);
Which[
OtherCount>0,                             {False,FourCount,"Done"},                (* NOT a potential Swish *)
OneCount==ThreeCount==0, {True,  FourCount,   "Done"},              (* A complete Swish of length FourCount *)
OneCount==ThreeCount==1, {True,  FourCount,   "NotDone"},      (* A partial Swish of current length FourCount *)
True,                                                     {False, FourCount,   "Done"}                   (* Messed up it should not get here *)
]
]

Each Stack (and card) has 4 possible equaivalet symettry-related representations.  I need to make sure that I am always using a canonical representations. I am simply going to use the first stack in the default order for the 4 possibilities as the canonical representative of the equivalence class.

SymmetryClass[Stack_]:= Module[
{RevStack},
(* RevStack is the Flip around the long Edge *)
RevStack=Map[Reverse,Stack];
(* Union Removes Duplicates and Sorts into Canonical Order *)
Union[{Stack, RevStack, Reverse[Stack], Reverse[RevStack]}]
]
CanonicalStack[Stack_]:= SymmetryClass[Stack][[1]]

{test1,test2,test3,test4}={({{1, 0, 0}, {0, 3, 0}, {0, 0, 0}, {0, 0, 0}}),({{0, 0, 0}, {3, 1, 0}, {0, 0, 0}, {0, 0, 0}}), ({{0, 0, 3}, {0, 0, 0}, {0, 0, 0}, {0, 0, 1}}),({{0, 0, 0}, {0, 0, 1}, {3, 0, 0}, {0, 0, 0}})};
Map[MatrixForm,SymmetryClass[test1]]
MatrixForm[CanonicalStack[test1]]

SwishAddSingleCard[{Stack_,CardsInStack_},{CardNumber_, CardsInDeck_}] := Module[
{SymCards,TestStacks,Card=CardsInDeck[[CardNumber]],NewStacks,NewCardsInStack},
SymCards=SymmetryClass[Card];
TestStacks=Table[
CanonicalStack[Stack+SymCards[[i]]],
{i,1,Length[SymCards]}];
NewStacks=Select[TestStacks, SwishTest[#][[1]]&];
NewCardsInStack=Sort[Append[CardsInStack,CardNumber]];
Table[
{NewStacks[[i]],NewCardsInStack},
{i, Length[NewStacks]}]
]

Deck={test1,test2,test3};

Test=SwishAddSingleCard[{test1,{1}},{2,Deck}];
Table[MatrixForm[Test[[i,1]]],{i,Length[Test]}]
Test[[All,2]]

I need to keep track of which cards have been added (or more particularly which cards are left to be added) which is a little complicated because there can be mpore than one copy of a card in the deck. I am going to use the “number” of the card in the deck to keep track,

SwishAddCards[{Stack_,CardsInStack_},CardsInDeck_]:=Module[
{Flag="NotDone",CardsLeft,NewStack, NewCardsInStack},
CardsLeft=Drop[CardsInDeck,CardsInStack];

NewStacks=SwishAddSingleCard[NewStack,CardsLeft[[1]]];

While[
And[Flag=="NotDone", nCurrent<nMax],
NewCard
Table[
SwishAddSingleCard[Stack,ListOCards[[i]]],
While[ ListOCards≠{}, 


]

Testing=SwishBuild[test1,test2];
Map[ MatrixForm, Testing]

Binomial[60,2]

Swic

SwishBuild[Testing[[1]],test3]
SwishBuild[Testing[[2]],test3]

4^11