don't leave parts of the bootloader in the kernel's address space

Beginne damit, src/binary/level_4_entries.rs rund um die erste 512GiB-Reservierung und src/binary/mod.rs rund um das context-switch- und GDT-Mapping zu lesen. Verfolge, wie die Seitentabelle des Kernels und Mappings erstellt werden; fertig ist die Aufgabe, wenn die Bootloader-Teile nicht mehr im Adressraum des Kernels verbleiben, das temporäre context-switch-Mapping behandelt wird und der Speicherort der GDT offengelegt oder konfigurierbar ist.

While implementing finer granular ASLR I came across this comment:
https://github.com/rust-osdev/bootloader/blob/ac46d0455b41c11e5d316348d068df1c495ce0af/src/binary/level_4_entries.rs#L40
We mark the first 512GiB of the address space as unusable for dynamically generated addresses. I think we do this because we identity map the context switch code into kernel memory and this code most likely resides within the first 512GiB of the address space:
https://github.com/rust-osdev/bootloader/blob/a445433010960ec5d8a8b94a85fcac16a00489b5/src/binary/mod.rs#L166-L181

This causes a number of (admittedly small and unlikely) problems:

• The identity mapped pages could overlap with the kernel or other mappings
• We don't expose the identity mapped addresses to the kernel in Mappings
• An attacker could make use of the identity mapped pages to defeat ASLR
• We mark so a lot of usable memory as unusable and because of that we can't check for overlaps because there would be a lot of false positives. We currently just ignore overlaps.

We could probably work around those problems while still mapping parts of the bootloader into the kernel's address space, but I'd like to propose another solution: We use another very short lived page table to do the context switch. This page table would only map a few pages containing code that switches to the kernel's page table. Importantly, we would set the page table up in such a way that the kernel's entrypoint is just after the page table switch instruction, so we don't have to use any code to jump to the kernel, it would simply be the next instruction.
I don't think we could reliably map such code into the bootloader's address space because we'd have to map the code just before the kernel's entrypoint which could be close to bootloader's code, so that's why I want to use a short-lived page table.

We also identity map a GDT into the kernel's address space:
https://github.com/rust-osdev/bootloader/blob/a445433010960ec5d8a8b94a85fcac16a00489b5/src/binary/mod.rs#L183-L193
We should probably make the GDT's location configurable and expose it in Mappings.

I'd be happy to work on a pr for this.