The 6502 CPU mostly treats everything it can see (addresses $0000-$FFFF) exactly the same, because the 6502 is a generic CPU. On NES, writing to specific addresses and reading from specific addresses can cause the NES to do certain things, or return certain information about the state of the NES hardware, but it's sort of invisible to the CPU. You can write to a place where the write won't have an effect, and the 6502 doesn't know this. You can read from places that return "garbage" values and the 6502 doesn't know the value is garbage. You can execute code from RAM, just like you can from ROM.
The zero page is just addresses $0000-$00FF. It's faster solely because it's one fewer byte to read for the CPU. "LDA" in code can actually be any one of several different bytes for the CPU: http://www.obelisk.me.uk/6502/reference.html#LDA
If you type LDA $0200, that gets assembled as $AD $00, $02. (The opcode for absolute addressing for LDA is $AD.) If you type LDA $00 that gets assembled $A5, $00. (The opcode for zero page addressing for LDA is $A5).
So a way to think about it is there are actually two different instructions to load a value from an address. One is faster because it doesn't have to read an extra byte. (The different instruction tells the CPU the byte is zero.) This is the reason the zero page is faster. There's usually an alternate byte for instructions that deal with it.
LDA $0000 ($AD, $00, $00) can be used instead of LDA $00 ($A5, $00) and the A will be the same value after either. But the $A5 version is ever so slightly faster. There are certain kinds of actions that can only be done on the zero page (mainly pointer things).
Zero page variables in NES Maker reside in "Routines\Basic\\Variables\ZP_and_vars.asm
The 6502 is unaware of which "variables" are 2 bytes, because the 6502 is unaware of the intent of your program. It does what it's told. What you'd consider to be a two byte variable does not even need to have both bytes to be contiguous (except for pointers) because the 6502 will only deal with them one at a time anyway. ($00 and $01 to store a 16 bit position is just as valid as $40 and $0206 to store that 16bit position.) NES Maker positions are actually an example of two byte variables that are not contiguous. (Object_x_lo for object 0 might be at $04A8, and Object_x_hi for object 0 might be at $049E)
What the assembler does is take all names given to it and turn them into the numbers they represent. The names only help you, the programmer. The 6502 doesn't see them.
Code:
lowByte = $04
lda lowByte
Gets assembled at LDA $04, which is $A5, $04
Code:
lowByte = $0200
lda lowByte
Gets assembled as LDA $0200, which is $AD, $00, $02.
Code:
lowByte = $0200
lda lowByte
lda lowByte+1
Gets assembled as LDA $0200, LDA $0201: $AD, $00, $02, $AD, $01, $02
You use a zero page variable the same way you would any other variable, or any other address. (A named variable is really just an address anyway.) ASM6 will use the faster LDA for them automatically (some assemblers won't!).
Even then, it's usually only marginally faster.
lda $0200 is four cycles.
lda $00 is three cycles.
So you get can get four zero page reads in the same time as three absolute reads. But the times it would help the most is dealing with arrays, and it's usually not faster for this.