Added Procedural Macro for Native Classes

[Redfire75369]

Resolves: #9

The addition of this new procedural macro allows easier creation of native functions to reduce boilerplate and chances for type errors.
It currently supports:

• Methods
• Accessors
• Accessors for Public Properties
• Static Methods,
• Static Value Properties
• Static Accessors

Below is an example of code using this macro:

#[ion::js_class]
mod switch {
	use ion::Result;
	use mozjs::conversions::ConversionBehavior::Clamp;

	#[derive(Clone, Debug)]
	pub struct Switch {
		b: bool,
		#[convert(Clamp)]
		pub i: i32,
	}

	impl Switch {
		pub const INT: i32 = 32;
		pub const DOUBLE: f64 = 4.20;
		pub const STRING: &'static str = "SPIDER\0";

		#[constructor]
		fn new(b: bool) -> Result<Switch> {
			Ok(Switch { b, i: 144 })
		}

		fn print(#[this] this: &mut Switch) -> Result<()> {
			eprintln!("SWITCH: {:?}", this);
			Ok(())
		}

		fn switch(#[this] this: &mut Switch) -> Result<()> {
			this.b = !this.b;
			Ok(())
		}

		fn spiderfire() -> Result<String> {
			Ok(String::from("SPIDERFIRE"))
		}

		#[get]
		fn b(#[this] this: &Switch) -> Result<bool> {
			Ok(this.b)
		}

		#[set]
		fn set_b(#[this] this: &mut Switch, b: bool) -> Result<()> {
			this.b = b;
			Ok(())
		}

		#[get]
		fn get_a() -> Result<i32> {
			Ok(Switch::INT)
		}

		#[set]
		fn c(_: bool) -> Result<()> {
			eprintln!("Pranked!");
			Ok(())
		}
	}
}

The rough equivalent of this code in TypeScript would be

class Switch {
	static INT = 32;
	static DOUBLE = 4.20;
	static STRING = "SPIDER";
	
	constructor(b: boolean) {
		self._b = b;
		self._i = 144;
	}
	
	print() {
		console.log(this);
	}
	
	switch() {
		this.b = !this.b;
	}
	
	static spiderfire() {
		return "SPIDERFIRE";
	}
	
	get b() {
		return this._b;
	}
	
	set b(b: boolean) {
		this.b = b;
	}
	
	static get a() {
		return Switch.INT;
	}
	
	static set c(_: any) {
		console.log("Pranked!");
	}
	
	get i() {
		return this._i;
	}
	
	set i(i: number) {
		this._i = i;
	}
}