Make philos drop a fork when the other is taken

Instead of making a fork a mutex, it now holds its state - whether it is
taken. This makes it possible for a philo to check, whether he can grab
both forks and if they cannot, they won't hold any fork.
I thought about approach before but my mind was locked onto using the
function pthread_mutex_trylock which is not permitted by the subject.

Make the sleep between death check be max 100 us

This is implemented so that main checks well fed condition more
frequently. Without the well fed condition can be satisfied for a long
time before main notices, particularly for long time_to_death.

Make main wait for a possible philo death

This makes main less demanding as it also enters sleep when no
philosopher's death is near.

Remove whitespace from end of lines in Makefile

Further change cleanup order

To make helgrind errors disappear, delete every mutex shared between
threads only after joining all the threads. This ensures that
no thread can access a mutex after the removal of the mutex because
no thread exists then.

Add the check for well fed philosophers

Format to comply with the 42 Norm

Add missing index increment, change cleanup order

The program only checked the forst philo for starvation.

The change in the cleanup order is needed because without the change
(forks) mutexes were deinitialized before joining the (philo) threads.
This could lead to a philo waiting for a fork, which has just been
cleared, leading to undefined behavior (endless wait). When the main
thread joins all the threads it gets gets stuck in the one waitin for
a fork.

Join the threads for valgrind not to complain

Fix discrepancy caused by confusing ms and us

Implement checking for the death of philosopher

Also minor refactoring

Implement the philo actions

Implement seat_philosophers

Thanks to the change of how the program keeps track of time
it is possible to set the "last_eaten" member of philo in advance
(to zero - the start) without slowing the seating.

Thanks to this, no delay is necessary before the program checks whether
philos died of hunger. (It was needed in old branch, because
philosophers initialized their own time at the start of their
existance, and the check could happen before the time was set)

Add initialization of some members of philos

Fix allocation of wrong size

The way the allocation was written, it allocated space for pointer
instead of the structure pointed to. This has been corrected.

Fix logic bug

Implement conditional compilation

Before this commit, compilation would stop at file parsing.c
with error (warning + -Werror) caused by -Wtype-limits.
Conditional compilation is added so that the offending if statement
is not present, when not needed.

The #if directive could have only been set up around the problematic
if statement. The 42 Norm however forbids using macros anywhere but
the global scope.

This made me write the the affected functions twice, which then broke
the 5 function limit per .c file. Hence this commit is quite large
for such a small change.

Implement initialization, cleanup and mutex struct

The mutex struct is implemented because pthread_mutex_destroy
produces undefined behaviour when supplied with uninitialized mutex.
The struct holds information whether the mutex has been initialized
succesfully.

The header file philo.h has also been filled with declarations of
functions used in main so that Makefiles compiles every file to object.
This is done for easier checking of compile errors.

Remove unnecessary include

Implement parsing of input

Add Makefile (doesn't compile yet)

Change the context of the time variables

This change is preliminary as the code that handles this is yet to be
written. I decided to do this because I think it will not add any
complexity but will make the code more portable (as useconds_t needs
not be huge this way)?

Create outline of the solution

Add .gitignore as an initial commit