DW3 (US) is a 512KB MMC1 ROM.
That is a somewhat unique case.

$7EBC4 is near the end of the ROM, so actually, $7C000-7FFFF (add $10 for the header) is always located in $C000-FFFF of the CPU address space, so actually, the jump would need to be to $EBB6, no BBB6.

Also, the unique part is that both $3C000-3FFFF and $7C000-7FFFF can be mapped into that part of CPU . (which is used depends on the MMC1's 256KB bank select register)
Not sure if DW3 uses both locations, so if the code suddenly breaks, you might need to check $3EBB6's code too.

Also, RAM only uses $0000-07FF for the NES internal RAM and $6000-7FFF for the cart RAM.
$4000-4017 are register for sound and a few I/O registers.
The rest is unmapped space.
(well, the FDS uses $402x and $403x, but that's besides this topic)

Another thing I should add is that if you're looking to write some code, you should look between $8000-BFFF (some 16KB bank in the ROM) and $C000-FFFF (which is either ROM $3C010-4000F or ROM $7C010-8000F depending on the previously-mentioned register).

If there's no free space, you could use bankswaps if there's free space elsewhere in the ROM (and a little free space in the CPU $C000-FFFF region), but that is a little more advanced topic.

There are plenty much documents for the 6502 and similar CPUs.
More or less commented game disassemblies are  on the net.
Romhacking.net has Metroid and Super Mario Bros. DASM to download.
Also the same CPU is used in Atari 2600,5200,7800,PC-Engine and C64 or Apple 2
and other systems.The 6502 is a very restricted CPU and thus easy to understand.
Thats why Master System or MSX hacking is more difficult.

I always thought it was because of the small table sizes and general lack of graphics/script compression.

While the primative nature of the 6502 can make some assembly operations tricky (have you ever done mulitplation or division on the thing?), I think the primary advantage of it and the rest of the NES is that it's relatively small size makes it easy to keep the state of the system in your head.

With only a handful of CPU registers and a (relatively) small number of graphics and sound registers, I find it fairly easy to remember what's stored where and what not. On more complex systems, keeping track of it all can be a pain.

The biggest drawback of the NES is that it's eight bit. This makes doing anything involving large numbers or addresses (which are 16 or 24 bit) more complex than they would be on a wider CPU. However, the small instruction set makes it easy to learn (if not, neccessarily easy to code). I've found that I've memorized the whole ISA without even conciously trying to do so. (Which isn't the case on other archtectures I've coded ASM on.)

On the other tentacle, a nice orthoganal RISC architechture would be the bomb. However, the systems that uses such CPUs have so many other complications that most of them are a poor choice for a beginner. (With the possible exception of the GBA. The ARM instruction set has some strange complications, but it's pretty clean and the GBA's additional hardware is simple, like old school consoles, rather than super complex, like most modern machines.)

The other reason that the NES is good for newbies is the vast ammount of documentation, utilities, tutorials, etc. that exist for it. Furthermore, it seems that most hackers have some experiance with it, so when you ask for help, there are a large number of people out there willing (and able) to help you.

I actually tried to do multiplication on the NES, using some manner of shifts, though a loop would accomplish the job (slowly). (like 6x5 = 6x4 + 6x1 = (6 left-shift 2) + 6 instead of 6+6+6+6+6). Don't remember if even finished a routine, though.
(yeah, I'm talking about integer multiplications. Floating point could be a mess, and would definitely be slow.)

Not sure if there's a simple way to do division, aside from a subtraction loop (would probably have to settle for an integer and remainder result).

Too bad nobody's figured out how the low level behavior of the SNES mult/div registers.

I wouldn't even consider doing floating point on a 6502, if you need subdecimal numbers, simply use fixed point. Multiplication and division are, as mentioned above, simply a series of shifts and additions or subtractions. I actually learned how by discovering the routines in my Final Fantasy dissasembly commenting project.

It's not true that you don't need multiplication or division in NES games. RPGs need both, and often at 16 bit or more. However, the algorithms for (somewhat) fast routines to handle advanced math on restrictive architectures are well documented, so it's not that bad. (I even saw a routine for square roots in 6502. (Although not in a game.) Eww.)