I was part of the conversation on comp.lang.scheme back when they were inventing hygienic macros, so I know all the arguments.
The thing is, doing macros at all is going to be very hard in a block-based language. In Lisp, it's easy because code is automatically data -- the surface representation is a list. Our scripts are first class, but they're atomic; there's no way to look inside them. So the first thing I have to do is invent a translation between blocks and manipulable code. That's already messy: Do I treat variable references as a special case, as in Lisp, or do I just represent them as niladic functions, which is how they look as blocks? How do I represent the header (the prototype, in our documentation) of a procedure? Lisp has the procedure's name as a single atom at the beginning, but our blocks' titles are spread out all over the block. All that sort of thing has to be specified before we begin.
So once that's ready to go, I want to be able to test its usability without debugging hygienic macros at the same time. FEXPRs I can implement in my sleep. So after that's debugged, then I can think about implementing hygienic macros instead.
But, let's talk about why you think it's a good idea for us. Our users aren't writing humongous industrial software in teams of 500 programmers. They're kids. Back in the day, when they first invented the R5RS macro system, there were a bevy of comp.lang.scheme posts from famous Knights of the Lambda Calculus who couldn't figure out how to express what they wanted to do hygienically. By contrast, anyone can understand FEXPRs. They have to be taught about the danger of name capture, yes, but I think that's an easier lesson than using hygienic macros.
As an analogy, Logo is dynamically scoped because, for several reasons, that's better for learners. I can go into the reasons if you like. I wish Snap! were dynamically scoped. Jens won't allow it because it would make our interpreter slower. (I thought I had a solution to that problem, but my solution fails in cases of tail call elimination.) That's actually a pretty good example, because hygienic macros are the compile-time analog of lexical scope.
So when you say "fexpr’s seem like a bad idea," is that on general principles or do you have a teaching reason in mind?
I admit that my slogan "Snap! is Scheme disguised as Scratch" would sort of push in the direction of hygienic macros. But historically we built Snap! more with the idea of Logo disguised as Scratch. It was just when we added lambda that we started thinking more in Scheme terms.