This is the first PR (indicated by P1 as in Part 1) needed to implement RIP-7728.

Purpose of the PR

I've decided to split this implementation into multiple parts (there will probably be two parts)

1. P1 (this PR) "concentrates" on general code structure and skeleton for implementing the rollup precompiles
2. P2 (next PR) will implement L1SLOAD precompile (actual implementation is easy)

Notes about "code skeleton" for rollup-precompiles

My current view of the project (rollup-geth) is that implementing specific RIPs/EIPs shouldn't be that hard, what I think will be hard is answering (or better said, writing code for) these two questions:

1. How can we add (and organize) code so that when geth changes, it's easy for us to "bring in" those changes to the repo
   By easy, I mean most importantly that the process is not error-prone and ofc. that we don't lose too much time on margining/rebasing/whichever strategy we decide on
2. How can we add (and organize) code so that when L2-rollup-geth wants to "bring in" our code changes, it's easy on them
   The definition of "easy" is the same as above

This PR tries to answer both requirements, but just for precompiles. That being said, even though we are "only" dealing with precompiles in this PR, the requirements for L1SLOAD required extending how precompiles work. Specifically, I had to:

1. Find a way how to best "inject" eth.Client into the precompiled contract
2. Find how to deal with the fact that not all L2s are accessing the required latest L1 block in the same way. E.g. for Arbitrum, block.number is the latest L1 block (not L2(!!!), and op-stack/scroll uses L2 contracts to store this info.

Implementation details

The idea was to create new "rollup" files so that we don't have too many changes (preferably just a couple of lines) in files that already exist in the official geth (e.g., vm/evm.go or vm/contracts.go) - this is why contracts_rollup.go exist.
And similarly, to create new files, which would L2-rollup-geth forks override - contracts_rollup_overrides.go. Ideally to change the functionality we are offering, the L2-rollup-geth would just replace or copy over the contracts_rollup_overrides.go file.

I need feedback on work so far that's why I'm opening this PR now. I don't think the specific implementation of L1SLOAD is that important ATM.

If you like the route I'm headed, I'd like to have a similar approach for other "stuff" we touch (e.g. flags.go). I don't think it'll be easy/possible to have this approach for everything, but if you agree, I'd like to experiment with it further.

Note

I tried to experiment with having a rollup/ folder (in root) where we could put all our changes, but that doesn't seem feasible:

As it is visible from the screenshot this would yield even huger diff; we would have to export private "stuff" from the folders/packages - this would be even messier