Microcontroller memory write cycles
Modern processor architectures allow you to address a contiguous memory space with the same data bus, even when you are accessing multiple types of memory (e.g. RAM, ROM, and Flash). As it turns out, this is quite handy as it allows your program to read/write RAM and read from Flash without doing any special tricks to switch memory types.

This is the same principle as an external data bus that can access a discrete RAM chip within a certain address range and a discrete ROM chip within a different address range, even when both chips are on the same bus and within the same address space.

On a modern microcontroller, these RAM/ROM/Flash sections are all included together on the same part and may be accessed by the same data bus within the processor.

Function registers are in RAM, and may be read/written as much as you'd like with no penalty. Your example of an ADC register that is updated constantly is a good one; RAM is used to store the ADC results in that register and it can be accessed on the same data bus with the flash memory.

Program code is usually in the flash space, and this is (usually) read-only. However, some processors do allow you to erase and re-write sections of the internal flash memory. This isn't as easy as writing to RAM; there are usually some special instructions that tell the processor which page to erase, etc. Most vendors will provide a library and/or example code to do this, as in the case of an EEPROM emulated flash area you mentioned.

In most microcontrollers, writing to flash is the "easy" transition (1s get changed to 0s) and can be done on a byte-by byte basis. Erasing (0s back to 1s) is not so targeted and is typically done in blocks (page, sector, etc.) Since this erase requires a higher voltage, there is an on-chip charge pump to generate this flash erase voltage.

This higher erase voltage has two consequences: erase cycles are typically much slower than reads (a charge must be built up and the erase must be verified), and the high voltage pulses do wear down the flash a little with each erase cycle. Thus, erasing flash should be done sparingly.

You are right that vendors build in margin to these life estimates, but you should take care when designing an application that erases/writes to flash (self-programming) so that you do not wear out your flash memory before your product has exceeded its design lifetime.