What does this PR do?

This PR opens the gates to the extension of a container, defining lifecycle hooks that can be leveraged by the consumers of the library to extend how a container is defined.

We have defined 8 lifecycle hooks:

1. Creating, executed right before the container is actually created by the Docker engine
2. Created, executed right after the container is created by the Docker engine
3. Starting, executed right before the container enters the Running state
4. Started, executed right after the container enters the Running state
5. Stopping, executed right before the container is stopped
6. Stopped, executed right after the container is stopper
7. Terminating, executed right before the container is terminated, removed from the Docker engine
8. Terminated, executed right after the container is terminated

For that, we are defining two types of hooks: one getting access to the container request (which defines the container), and the second getting access to the running container created by the aforementioned request.

Each hook will be backed by an array of functions that returns an error and receive the Go context as first argument plus a second argument:

1. the container request for the Creating hook, as the representation of the container type does not exist at this moment.
2. the container for the rest of the hooks, as the representation of the container type has just been created.

If a hook returns an error, then the lifecycle will be stopped at that moment. For that reason, I'm not using defer to execute the Post hooks.

To add the hooks, we have defined a LifecycleHooks fiels in the ContainerRequest struct, so that it's possible to define how the container will behave when requesting a container.

With this implementation users would be able to define as many functions as they need to customize the container, e.g. passing an array of functions to the PreCreates field of the lifecycle, and/or an array of functions to the PostStarts field of the lifecycle. I've provided with a test demonstrating how it's possible to leverage the lifecycle: the tests adds a "log entry" everytime the life cycle hooks are called, and we assert that the life cycle is honoured (creating > created > starting > started > stopping > stopped > starting > started > terminating > terminated)

Finally, the docs have been updated to include the lifecycle hooks explanation in the "Create Container" section. Render URL here: https://deploy-preview-1036--testcontainers-go.netlify.app/features/creating_container/#lifecycle-hooks

Why is it important?

As a user of the library creating a container, I want to be able to execute code just before/after the container is created/started/stopped/terminated.

Follow-ups

I'd like to identify all code that happens out of the lifecycle hooks defined here but acting as a hook, wrapping them into hooks that will be part of the lifecycle