Because of how they saved the ID's on your storage. Here is the source for all this.
Chunks are split into 16x16x16 segments. Each segment contains various arrays of byte data about that segment, with each index in the array corresponding to a physical location in the segment (so index 0 might indicate the bottom-most left block, 1 is one block over, etc). We only care about two of these arrays, the "Block" array and the "Add" array. Now the "Block" array contains 4096 bytes (16x16x16=4096=1 byte per block), where the "Add" array contains 2048 bytes (16x16x16=4096/2=2048=1 byte per 2 blocks=4 bits per block).
Numerical ID's for blocks are expressed as 12 bits, which is where the 4096 block ID limit for modded comes from. The first 8 bits are stored in the "Block" array, and the last 4 bits are stored in the "Add" array. When the game reads a given position in the segment, it reads the first 8 bits from the "Block" array, then reads the last 4 bits from the "Add" array, and shifts the 4 bits over to the left by 8 positions. Then it adds the two values together to get the final, full ID. Now the problem is, in vanilla, the "Add" array is somehow disabled. Mods activate it, but Mojang has yet to. So Mojang is still only using 8 bits to store the ID, which results in the 256 block ID limit the game has currently.
They could activate the "Add" array, which would raise the block ID limit to 4096 in vanilla, but 4096 is still pretty low: I ran out of block ID's with 280 or so mods in 1.7.10, when I could easily run 300+ mods on my system. So they're coming up with a new way of storing ID's, that keeps this current system in place, but extends off of it such that each individual ID is unique to the segment it's stored in. Under 1.13's system, chunk segments will also store a thing called an "ID palette", which maps textual ID's ("minecraft:stone") to numerical ID's (3). Because the palette is local to the chunk segment, it moves the 4096 block ID limit from the game itself to each individual chunk segment, which coincidentally each chunk segment can store at maximum 4096 unique blocks (16x16x16=4096), so it's impossible for a single chunk segment to run out of ID's. And that's where the whole "infinite ID" thing is coming from, under 1.13 the limit will be however many block instances an array in Java can store, which at minimum is around 2 billion or so, assuming arrays use signed 32-bit integers.