Implement new Concept Exercise: memory-allocation

This issue describes how to implement the `memory-allocation` concept exercise for the F# track.

## Getting started

**Please please please read the docs before starting.** Posting PRs without reading these docs will be a lot more frustrating for you during the review cycle, and exhaust Exercism's maintainers' time. So, before diving into the implementation, please read up on the following documents:

- [The features of v3](https://github.com/exercism/v3/blob/master/docs/concept-exercises.md).
- [Rationale for v3](https://github.com/exercism/v3/blob/master/docs/rationale-for-v3.md).
- [What are concept exercise and how they are structured?](https://github.com/exercism/v3/blob/master/docs/features-of-v3.md)

Please also watch the following video:

- [The Anatomy of a Concept Exercise](https://www.youtube.com/watch?v=gkbBqd7hPrA).

## Goal

The goal of this exercise is to teach the student the basics of the Concept of Memory Allocation in F#.

## Learning objectives

- Know what the stack and heap are.
- Know what the garbage collector is.
- Know how the stack and heap are different.
- Know what the large object heap is.
- Know what reference and value types are.
- Know how reference and value types relate to the stack and heap.
- Know how to make a discriminated union, record, tuple or class a struct.

## Out of scope

- Memory locality.
- Memory pooling.
- Pointer semantics.
- `Span` and `Memory`
- Readonly semantics and by reference arguments.
- Discussion of profiling tools (referring to them is fine).

## Concepts

The Concepts this exercise unlocks are:

- `memory-allocation`: know what the stack and heap are; know what the garbage collector is; know how the stack and heap are different; know what the large object heap is; know what reference and value types are; know how reference and value types relate to the stack and heap; know how to make a discriminated union, record, tuple or class a struct.

## Prerequisites

This exercise's prerequisites Concepts are:

- `classes`: know how to define a class.
- `records`: know how to define a record.
- `tuples`: know how to define a tuple.
- `discriminated-unions`: know how to define a discriminated union.
- `attributes`: know how to add attributes.

Any data types used in this exercise (e.g. `strings` or `integers`) should also be added as prerequisites.

## Resources to refer to

### Hints

- [Structs][structs]: describes what structs are and how to define a type (class) as a struct
- [Struct tuples][struct-tuples]: how to define struct tuples.
- [Struct records][struct-records]: how to define struct records.
- [Struct discriminated unions][struct-discriminated-unions]: how to define struct discriminated unions.

The following links all use C# as their language, but the concepts apply equally as well to F#:

- [Value types][value-types]: introduction to value types.
- [Reference types][reference-types]: introduction to reference types.
- [Stack versus heap][stack-vs-heap]: how the stack and heap work.

### After

- [Structs][structs]: describes what structs are and how to define a type (class) as a struct
- [Struct tuples][struct-tuples]: how to define struct tuples.
- [Struct records][struct-records]: how to define struct records.
- [Struct discriminated unions][struct-discriminated-unions]: how to define struct discriminated unions.

The following links all use C# as their language, but the concepts apply equally as well to F#:

- [Value types][value-types]: introduction to value types.
- [Reference types][reference-types]: introduction to reference types.
- [Stack versus heap][stack-vs-heap]: how the stack and heap work.
- [Value types vs reference types][value-types-vs-reference-types]: in-depth comparison between value and reference types
- [Garbage collection][garbage-collection]: how garbage collection works in C#.
- [Large Object Heap][large-object-heap]: what the Large Object Heap is.
- [Garbage collection performance][garbage-collection-performance]: in-depth look into garbage collection performance.

## Representer

This exercise does not require any specific representation logic to be added to the [representer][representer].

## Analyzer

This exercise does not require any specific logic to be added to the [analyzer][analyzer].

## Implementing

To implement this exercise, please [follow these instructions](https://github.com/exercism/v3/blob/master/languages/fsharp/reference/implementing-a-concept-exercise.md).

## Help

If you have any questions while implementing the exercise, please post the questions as comments in this issue.

[how-to-implement-a-concept-exercise]: https://github.com/exercism/v3/blob/master/docs/maintainers/generic-how-to-implement-a-concept-exercise.md
[implemented-exercises]: https://github.com/exercism/v3/tree/master/languages/fsharp/exercises/concept/README.md#implemented-exercises
[reference]: https://github.com/exercism/v3/blob/master/reference/concepts/memory-allocation.md
[reference-example]: https://github.com/exercism/v3/blob/master/reference/types/string.md#implementations
[analyzer]: https://github.com/exercism/fsharp-analyzer
[representer]: https://github.com/exercism/fsharp-representer
[meta-design]: https://github.com/exercism/v3/blob/master/languages/fsharp/exercises/concept/numbers/.meta/design.md
[meta-config.json]: https://github.com/exercism/v3/blob/master/languages/fsharp/exercises/concept/numbers/.meta/config.json
[docs-concept-exercises]: https://github.com/exercism/v3/blob/master/docs/concept-exercises.md
[value-types]: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/value-types
[reference-types]: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/reference-types
[stack-vs-heap]: https://www.c-sharpcorner.com/article/C-Sharp-heaping-vs-stacking-in-net-part-i/
[garbage-collection]: https://docs.microsoft.com/en-us/dotnet/standard/garbage-collection/fundamentals
[value-types-vs-reference-types]: https://adamsitnik.com/Value-Types-vs-Reference-Types/
[large-object-heap]: https://docs.microsoft.com/en-us/dotnet/standard/garbage-collection/large-object-heap
[garbage-collection-performance]: https://docs.microsoft.com/en-us/dotnet/standard/garbage-collection/performance
[struct-tuples]: https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/tuples#syntax
[struct-records]: https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/records#remarks
[struct-discriminated-unions]: https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/discriminated-unions#struct-discriminated-unions
[structs]: https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/structures