Restructure environment to reflect a VS project
Remove unnecessary instantiations of Program.

There is a distinction between a class and an object. Think of a class as
a cookie cutter. It's not the actual cookie, but it gives you the shape
you want after you use it to cut the cookie dough. The object is the
cookie dough shaped after the cookie cutter.

A class is simply a set of definitions that tell what an object should be.
We say an object is instantiated when we use `new` operator. That is,
`Program program = new Program()` will instantiate an instance of the
Program class. We can call any public method defined by the Program class
on the program object we instantiated. It is unnecessary, and in fact
terrible practice, to create a new instance of the Program class every
time you want to call a method.

Whenever you call the `new` operator to instantiate an object, a chunk of
memory is allocated for that object. Every member variable within that
object (in this case, the randx variable is the only member variable) is
reinstantiated. So it's even worse in this particular use! Instantiating a
new instance of Random every time means it gets reseeded. If it's being
seeded with a predictable source (i.e. time), then it's effectiveness
deteriorates.

Instead, what you should do is the following:
* If a method needs to call a method within the same class, then just call
  directly without instantiating a new object. This will cause the method
  to be called on the same chunk of memory allocated for the object.
* If you need to call a method outside of the instance of a class (i.e.
  from another class or from a static method), then create one single
  instance of the class (see Program#Main()) and call all the methods you
  need from that single instance. Don't create an instance for every call
  you want to make. That's horrible.
Move program logic into a separate instance method.

This is just applying a different pattern for achieving the same results.
Instead of putting all the logic in the `Main()` static method, we'll
create an instance of `Program` and call an instance method that provides
the same logic.
Remove unnecessary `Program#Options()` method.

There is no point for the `Program#Options()` method. The same logic can
be applied more effectively by using the `default` case in the switch
statement. That is, if no cases before the default are matched, then the
default case is applied.
Add quit option to allow the user to exit.
Remove usage of `goto`.

NEVER use the goto statement. That is absolutely horrible practice because
it leads to spaghetti code. Apply the equivalent logic using loops
instead. In this case, we're just looping indefinitely until the user
quits.
Continue rather than wait for user input.

Either output "Press a key to continue..." or don't wait for user input to
continue after performing an action. It's just not user-friendly and will
confuse your user.
Trim whitespace from user input for convenience.