We build games that are two-fold. First, they are "determine if we disagree on the assignment of switches". If we disagree on the assignment of switches, we consider the game "won" -- or, more accurately, we'll call that game "sour".
Second, there is the "determine if exactly one person has been here in the last 20 days" victory.
If we have determined that we have a disagreement on every game but our own (that they are sour games), and we get a victory on the remaining game, then we know that we have won the entire game.
Now, as for disagreements, we can do the "on even days send a 1, on odd days send a 0" pattern. If we ever see something that disagrees with our assumption, then we know that there is a disagreement. (Edit: actually, a block where everyone sends 0 is sufficient, as in my system there is only 2-fold symmetry in what the switches mean)
Amusingly, we might be able to speed up this system by lieing sometimes once we have determined there is a disagreement. As a simple solution, imagine that once we have determined that game N is in disagreement about the assignment of bits, we start sending random messages in the synchronization period for game N. This means whomever goes next has a 50-50 chance of also getting a desychronization. Which would allow desychronization to spread exponentially through the population.
For a n+1 length block of synchronization, with exactly 1 bit in our switch assignment being "off", and nobody knowing that there is a problem, there is a (19/20)^n chance that the person with the wrong bit will broadcast the fact that their bit is wrong to someone else. If they first learn that their bit is wrong, there becomes a (19.5/20)^n chance they'll broadcast their error to another player. That is worse, so let us be conservative.
Suppose block lengths of 30 -- that is long enough that even in the worst cast, a rebroadcast is more than 50% likely per block.
Each successful broadcast of error spreads it to another prisoner. And the chance of a broadcast keeps on going up for a bit, until the problem is reaching the last person who doesn't know the game is a sour game.
This has to go on over all 2^20 games (I think we can do this with two switch assignments per game, really!), until we reach the point where at least one player knows that 2^20-1 games are sour, and has a hope to win the actual game that isn't sour.
I cannot think of a way to safely communicate "between games" which games are sour without the receiver already knowing that 2^20-1 games are already sour, and that would be the goal of such communication. Or would it?
Once we have at least one player who has the sour-state of the entire system, we need a ridiculous number of repeats of the final game to clean things up. It might be an interesting idea to add in a game whereby we determine if everyone knows that every game except for one is sour!
... that is the "has everyone been in the room" game! If instead of playing the "has the last 20 games contained every player" from the start, we play a continuous set of 20 games of "send a 1 to the counter if you know that every game except for this one is sour", where we have all 20 players counting. Then somehow transition to playing the "has every 20 players been in the room" mode?
This gets tricky, because we need to both know that we know, and that everyone else knows. Or maybe we don't. Once we know that all games except for 1 are sour, we stop caring about what we pick up in the sour games. This means that other people could broadcast nonsense. So what we do is we wait until we personally know that everyone else knows all games but 1 are sour, then we change our broadcast strategy in this now known to be dead space, and start sending that we have changed our broadcast strategy.
When we know that everyone else has changed their broadcast strategy in the dead space, we start paying attention to inputs, as if they aren't random data.
This lets us transition the sour game bandwidth from finding out if the game is sour, to another game. Such as packed "has each of us been in the room in the block of 20 days" games.
Admittedly, the low odds of that happening sort of dominates any speedup in how often we play it. Still, I suspect it might be relatively expensive to get to the point where one person knows that all but one game is sour, and allocating more bandwidth to that determination (and less to the "block of 20 games") we might solve the problem faster.
On the other hand, if we split the bandwidth between blocks of 20 games, and determining that all but one game is sour, 50-50, such a speedup is limited by a factor of 2 (approx -- the seam between the blocks is somewhat wasted, but can be arranged to be minimal). And at the scales we are talking about, a factor of 2 isn't all that much.
Oh well -- I did find it interesting that we might actually be able to transition the use of blocks of bandwidth!