serde: Use error propagation

serde: Write JSON to file

serde: Data types and initial serialization

simple-http: Implement ThreadPool cleanup

Introduce Terminate message. Test this by only accepting two requests
and then letting `pool` go out of scope.

simple-http: Implement ThreadPool messaging

simple-http: Add scaffolding for thread pool implementation

Turn into library crate. Add ThreadPool stub to src/lib.

simple-http: Naïve unlimited threads

This introduces a DoS with too many parallel requests.

simple-http: Introduce a slow path

simple-http: Parse path from request

simple-http: Check hardcoded root path, add 404 page

simple-http: Initial skeleton

concepts: Add alternative Post implementation with states as types

concepts: require two Post approvals

concepts: Add Post.reject() transition

concepts: Rewrite Post without Option

This gets rid of a lot of extra Option handling code, at the price of
having to rebuild instead of pass through non-changing states.

concepts: Dynamic trait objects

concepts: Shared memory and mutex between threads

concepts: Threads and message passing

concepts: Rewrite Cacher tests using RefCell

Avoids an external crate.

Move top-level files into concepts/

As this now contains multiple projects, it was too messy.

Call Rust function from C: Complex cases

Add three functions which take/return strings and string arrays. This
creates some interesting problems how to combine the C semantics of
returning a char** with the Rust semantics of freeing objects once they
go out of scope.

This now also relies on the Rust standard library, which needs a few
system libraries. Link them.

Call Rust function from C: Skeleton

Implement the rest of c-mounts.c in Rust

Use errno crate for human-readable error formatting.

Initial libmount function call from Rust

Follow "A little C with your Rust" [1].

Set up cargo and main.rs skeleton and call one of the simplest possible
functions from libmount: mnt_get_fstab_path().

Use bindgen [1] to translate libmount's header file into a Rust
interface. This requires a few hacks:

 - bindgen does not accept the original header right away, as it can't
   find stdarg.h. Avoid this by dropping the (unnecessary) stdio.h
   include.
 - bindgen does not know about `size_t`. Hack around that with a typedef
   for now.
 - Suppress warnings about constant/identifier naming.

[1] https://rust-lang.github.io/rust-bindgen/command-line-usage.html
[2] https://docs.rust-embedded.org/book/interoperability/c-with-rust.html

C from Rust: Reference C programs

Add .gitignore

Iterators

Consistently use into_iter() with collect()

Replace unsafe test code with global_counter

https://docs.rs/crate/global_counter

Closures and Cacher object

Add integration test

Move helper functions into src/lib.rs

This enables writing integration tests. Pure binary crates can't have
them:

https://doc.rust-lang.org/stable/book/ch11-03-test-organization.html#integration-tests-for-binary-crates

Generics and Traits

Return style fix

File reading with standard fs API

File reading and error handling using ?

File reading and simple error handling

Split into functions

HashMap

test word_utils

Vector iteration

Move word_utils to separate file

Put functions into module

References, slices, Option