Replace getMethodNames/callMethod with annotations (#447)

When creating a peripheral or custom Lua object, one must implement two
methods:

 - getMethodNames(): String[] - Returns the name of the methods
 - callMethod(int, ...): Object[] - Invokes the method using an index in
   the above array.

This has a couple of problems:
 - It's somewhat unwieldy to use - you need to keep track of array
   indices, which leads to ugly code.
 - Functions which yield (for instance, those which run on the main
   thread) are blocking. This means we need to spawn new threads for
   each CC-side yield.

We replace this system with a few changes:

 - @LuaFunction annotation: One may annotate a public instance method
   with this annotation. This then exposes a peripheral/lua object
   method.

   Furthermore, this method can accept and return a variety of types,
   which often makes functions cleaner (e.g. can return an int rather
   than an Object[], and specify and int argument rather than
   Object[]).

 - MethodResult: Instead of returning an Object[] and having blocking
   yields, functions return a MethodResult. This either contains an
   immediate return, or an instruction to yield with some continuation
   to resume with.

   MethodResult is then interpreted by the Lua runtime (i.e. Cobalt),
   rather than our weird bodgey hacks before. This means we no longer
   spawn new threads when yielding within CC.

 - Methods accept IArguments instead of a raw Object array. This has a
   few benefits:
   - Consistent argument handling - people no longer need to use
     ArgumentHelper (as it doesn't exist!), or even be aware of its
     existence - you're rather forced into using it.
   - More efficient code in some cases. We provide a Cobalt-specific
     implementation of IArguments, which avoids the boxing/unboxing when
     handling numbers and binary strings.

src/main/java/dan200/computercraft/api/lua/IDynamicLuaObject.java

@@ -0,0 +1,45 @@
+/*
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2020. This API may be redistributed unmodified and in full only.
+ * For help using the API, and posting your mods, visit the forums at computercraft.info.
+ */
+package dan200.computercraft.api.lua;
+
+import dan200.computercraft.api.peripheral.IDynamicPeripheral;
+
+import javax.annotation.Nonnull;
+
+/**
+ * An interface for representing custom objects returned by peripherals or other Lua objects.
+ *
+ * Generally, one does not need to implement this type - it is sufficient to return an object with some methods
+ * annotated with {@link LuaFunction}. {@link IDynamicLuaObject} is useful when you wish your available methods to
+ * change at runtime.
+ */
+public interface IDynamicLuaObject
+{
+    /**
+     * Get the names of the methods that this object implements. This should not change over the course of the object's
+     * lifetime.
+     *
+     * @return The method names this object provides.
+     * @see IDynamicPeripheral#getMethodNames()
+     */
+    @Nonnull
+    String[] getMethodNames();
+
+    /**
+     * Called when a user calls one of the methods that this object implements.
+     *
+     * @param context   The context of the currently running lua thread. This can be used to wait for events
+     *                  or otherwise yield.
+     * @param method    An integer identifying which method index from {@link #getMethodNames()} the computer wishes
+     *                  to call.
+     * @param arguments The arguments for this method.
+     * @return The result of this function. Either an immediate value ({@link MethodResult#of(Object...)} or an
+     * instruction to yield.
+     * @throws LuaException If the function threw an exception.
+     */
+    @Nonnull
+    MethodResult callMethod( @Nonnull ILuaContext context, int method, @Nonnull IArguments arguments ) throws LuaException;
+}