This makes where look like another top-level comprehension clause like for and if, but it doesn't follow the same nesting rules as the other clauses. Which means that whenever something isn't trivial enough to just read holistically, trying to apply the dead-simple rule of "write each clause as a nested statement, in the same order" will just lead to confusion, instead of immediately telling you the interpretation.
Where that line is depends on how experienced you are with Python, how much time you've spent recently in a language with similar but not identical comprehension syntax, how tired you are, etc., but that doesn't matter--any comprehension with a where clause has at least three clauses, and is likely to be complicated enough to be over that line for some people. So, if you're going to recommend that this is only used when it's simple enough that it doesn't matter that the translation is confusing, that would mean recommending never using it, which implies that we shouldn't have it.
A new clause that nests in order, like some of your other variations, doesn't have this problem.
I think you're overcomplicating this. You want let to be a statement, but also have a value--but you only need one or the other.
As a statement, there's no need for a value; you're just creating or rebinding a variable for use in the controlled suite:
let x = foo():
if x:
print(x)
And in a comprehension, it's just another clause that converts to the identical compound statement and nests the same as other clauses:
[stripped for line in file let stripped=line.strip() if stripped]
Hopefully you don't want scoping, but if you do, it's pretty obvious that the scope is the controlled suite; still no need for an in clause.
If you really want a let expression instead of a statement, you still don't need an in clause unless you want scoping. Just make it an assignment expression whose value is the assigned value, just like in C and friends:
if let x = foo():
print(x)
Which extends easily to:
if (let x = foo()) > 5:
print(x)
[stripped for line in file if let stripped=line.strip()]
The only reason you'd need an in clause is if you wanted scoped expressions. But those would be almost useless in Python because, by design, you can't do too much inside an expression. But if you really want that, the design is again obvious: just as in functional languages, it's equivalent to a lambda call:
let x=foo() in (print(x) if x > 5 else None)
(lambda x: print(x) if x > 5 else None)(foo())
... which is obviously unpythonic enough and useless enough that I think scoped let expressions are immediately dismissible as an idea.