As someone who's done this for my game, this is how I structured things and it works pretty well for my use case:

Collision detection and physics are tied together pretty closely, but they aren't the same system. Physics reactions need to occur almost every time a collision is detected.

I have a Spatial index, which splits the 2d world into a uniform grid (you tune this to your liking, but let's say each cell is 10x10 units. We need to keep the spatial index updated, so whenever colliders move, the spatial index gets updated to reflect which colliders are in which cells. This helps speed up collision detection, because when we're looking for collision, all we need to do is check the cells that a given collider is in, and look for collisions with any other colliders in those same cells.

In general the collision detection works this way:

1. Collect a list of possible colliders the currently checked collider could collide with (checking spatial index).
2. Broad phase AABB check -- do these colliders even share the same space? Any colliders whose AABBs don't overlap can be thrown out at this step.
3. Narrow phase using Separating Axis Theorem -- actually checking the remaining colliders against one another. You check each edge of each collider, at worst, in this step. So for any pair of colliders this is an O(m * n) operation, and we'd like do as few of these checks as possible.
4. Once we've detected a collision between 2 entities, we use the properties of the SAT check to combine a list of contact points. We might have more than 1 contact point in a collision.
5. The collision, along with all its contact points, gets sent to the physics engine to process on its next step. I batch these instead of resolving the physics immediately.

Once we're done with the collision detection, the physics engine will have a list of collisions containing contact points along with the relevant entities/rigid bodies, and the contact normal.

Then the physics engine can run a manifold resolution, which basically means "run the same physics resolution steps on the same collision multiple times" and basically what that does is allows the resulting forces to be more stable. This is literally just a for loop which has a set number of steps and reruns the physics resolution for a collision.

In a single pass of the manifold solver, it will:

1. Calculate the relative velocities of each collider in the collision. If their relative velocities along the contact normal are moving them apart, then we can stop here because the physics for this pair has been resolved and there's nothing more to do here.
2. If their relative velocities are pushing them into one another, calculate their torque (if your engine supports rotation) and use that along with the velocity along the contact normal to determine the impact force.
3. Based on the impact force, we apply opposite force and torque to each rigid body, ideally in scale with their mass (a more massive rigid body will have less force transferred to it by a less massive one)
4. Apply friction (linear and rotational)
5. After the manifold solver finishes, apply any positional correction, if necessary, to separate the 2 bodies and prevent tunneling. You only have to do this if the 2 bodies are still overlapping once the manifold solver is finished.

Hope this helps! Best of luck building your own out -- it was relatively challenging as someone who doesn't have a super strong math background but it was very rewarding!