Static NAT, Port forwarding, Firewall support

Now vagrant-cloudstack can set a port forwarding rule when the virtual machine is deployed.

But there are some limitations.

* only 1 rule can be set
* unable to use in VPC because openfirewall is always true
* can't specify source CIDRs

This patch enables to create Static NAT, Port forwarding, Firewall rules  like Security Groups.
It also delete rules where the instance is destroyed.
This whole block more or less defeats the purpose of the code above it and is just repeated code.

They should at least utilise the translate_from_to method so you do not have to repeat that logic. I would also prefer to have even more generic translator methods, perhaps like this (untested):

```ruby
        def resourcefield_to_id(env, resource_name, resource_type, resource_field, options={})
          env[:ui].info("Fetching UUID for #{resource_type} named '#{resource_name}'")
          full_response = translate_from_to(env, resource_type, options)
          result        = full_response.find { |type| type[resource_field] == resource_name }
          result['id']
        end
```
```ruby
        def id_to_resourcefiled(env, resource_id, resource_type, resource_field, options={})
          env[:ui].info("Fetching name for #{resource_type} with UUID '#{resource_id}'")
          options = options.merge({'id' => resource_id})
          full_response = translate_from_to(env, resource_type, options)
          full_response[0][resource_field]
        end
```

Then this whole block:

```ruby
        def name_to_id(env, resource_name, resource_type, options={})
          env[:ui].info("Fetching UUID for #{resource_type} named '#{resource_name}'")
          full_response = translate_from_to(env, resource_type, options)
          result        = full_response.find { |type| type["name"] == resource_name }
          result['id']
        end

        def id_to_name(env, resource_id, resource_type, options={})
          env[:ui].info("Fetching name for #{resource_type} with UUID '#{resource_id}'")
          options = options.merge({'id' => resource_id})
          full_response = translate_from_to(env, resource_type, options)
          full_response[0]['name']
        end

        def ip_to_id(env, ip_address, options={})
          env[:ui].info("Fetching UUID for public_ip_address '#{ip_address}'")
          full_response = env[:cloudstack_compute].send("list_public_ip_addresses".to_sym, options)
          full_response = full_response["listpublicipaddressesresponse"]["publicipaddress"]
          result        = full_response.find { |type| type["ipaddress"] == ip_address }
          result['id']
        end

        def id_to_ip(env, ip_address_id, options={})
          env[:ui].info("Fetching name for public_ip_address with UUID '#{ip_address_id}'")
          options = options.merge({'id' => ip_address_id})
          full_response   = env[:cloudstack_compute].send("list_public_ip_addresses".to_sym, options)
          full_response["listpublicipaddressesresponse"]["publicipaddress"][0]['ipaddress']
        end
```
Could be replaced with something like this:

```ruby
        def name_to_id(env, resource_name, resource_type, options={})
          resourcefield_to_id(env, resource_name, resource_type, "name" , options)
        end

        def id_to_name(env, resource_id, resource_type, options={})
          id_to_resourcefield(env, resource_id, resource_type, "name" options)
        end

        def ip_to_id(env, ip_address, options={})
          resourcefield_to_id(env, ip_address, "public_ip_addresses", "ipaddress", options)
        end

        def id_to_ip(env, ip_address_id, options={})
          id_to_resourcefield(env, ip_address_id, "public_ip_addresses", "ipaddress" options)
        end
```