I am not a security expert. I am a programmer with good knowledge of math and some knowledge of this subject.
On the other hand if website allows attacker to try 1 password every second indefinitely, then attacker would need one million seconds (about 12 days) to guess your password. This is quite weak but if the website is of low value to attacker he might not be willing to spend 12 days to get your password and you can remain safe.
And finally if website is breached and attacker can get his hands on the actual database of hashed passwords, then he can use dedicated hardware to guess passwords extremely quickly, even thousand million per second, and he could guess your password within one second. (Speed depends on actual method used to store passwords.)
Consider password Rw!%LxLNr3jjwhich has 12 characters.
If attacker only knows that user has a password which can use any of the 90 characters I mentioned above, then he would need to try all possible combinations to guess it. He would most likely start from short ones, first trying all 1-character passwords (90 different), then all 2-character passwords (90*90 = 8100 different), then 3-character passwords (90*90*90 = 729'000 different) and so on. There are 285602902059438202247190 different combinations of 1-12 characters and even trying thousand million per second would take millions of years. So this password would be secure.
But if attacker knows that password was somehow generated using my example grid, he would not try all possible combinations. He would try to think of different ways this grid can be used, and most likely would again start from simplest ones which are fastest to check. Just taking a random row from grid is perhaps simplest of all. For one grid there are 17 possibilities and for 77 grids there are 77*17 = 1309, and after trying them all attacker would know this password since it is just one row from the grid.
I created a small program Password Grid to calculate how many paths like these can be created from different grids.
There are few things to consider here, for example path length and how many turns path should have. Longer path and more turns will make path harder to guess but also harder to remember.
Also when creating password from overlapping path (black example) you could use overlapping character(s) several times, which makes password longer but with less randomness. Or you can use it just once. For my calculations I will use latter approach so that black example creates 8 character password since "M" is used only once.
If you want a password of 8 - 20 characters with non-overlapping path, then with 77 different grids, by just using a straight line (blue) there are about 160'000 possible paths. With one turn (cyan) there are 8.7 million, with two turns (green) 210 million and with three turns (red) 3150 million different paths.
With up to 25% overlap allowed there are 7000 million different paths with three turns.
Complex shapes also allow more ways on how to construct password from given shape. For example the "happy face" shape above could mean password e&%:yE9y or e&y9Ey:% or many others.
For example a secret 4-character prefix created randomly using 90 different characters would make any password at least 90^4 = 65'610'000 times harder to guess.
I wrote "at least" because that number assumes that attacker knows you are using two-part password with a prefix and then second part which is created using grid(s). If he doesn't know that, he could try finding whole password from grid (which is impossible because it can't be found there) or guessing it without grid (which is also impossible if password is sufficiently long, see section "What attacker knows about password").
So if you have an initial password which would require 1'000'000 tries from attacker to guess it and you add such prefix to it, attacker would now need at least 65'610'000'000'000 tries. Even with one million tries per second attacker would need over two years. In extreme case where attacker can try thousand million guesses per second he could learn password within a day.
Many ifs there, so in practice such password would be quite secure.
Example calculation using Password Grid.
For example you could decide that when creating password, you change case of every letter on grid. So if grid has lowercase letter you use corresponding uppercase letter in password and if grid has uppercase letter you use lowercase letter.
Instead of changing every letter, you could change only first or last letter. Or maybe change only letters on even rows.
The question of how easy to remember they are is harder and depends on person, so I'm not going to consider that much. If I were to use something like this to store several passwords, I would most likely use a shared prefix to strengthen passwords and also to allow me to use simpler and easier to remember patterns when selecting passwords from grid.