mach_o.ksy: vm_prot should behave like a bit mask
Hi,

I'm new to the project and I'm looking at it for some personal projects.

In the specification of the Mach-O file format, the `vm_prot_t` type is represented by `vm_prot`, which is defined as an enum which can have the following values:

```
vm_prot:
  0x00: none
  0x01: read
  0x02: write
  0x04: execute
  0x08: no_change
  0x10: copy
```

However, `vm_prot_t` values are used as bit masks by all the tools producing, analyzing and using Mach-O files in Apple's operating systems. 

For example, by examining `/bin/cat` with `otool`, we can see that the __TEXT segment has an initprot of 0x5 (`VM_PROT_READ|VM_PROT_EXECUTE`) and maxprot of 0x7 (`VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE`)
```
sh-3.2$ otool -l /bin/cat
...
Load command 1
      cmd LC_SEGMENT_64
  cmdsize 552
  segname __TEXT
   vmaddr 0x0000000100000000
   vmsize 0x0000000000002000
  fileoff 0
 filesize 8192
  maxprot 0x00000007
 initprot 0x00000005
...
```

Therefore, it should be possible to combine different values of the `vm_prot` enum. 

I can think of two ways this could be implemented in the format specification:


1. Add all the valid combinations to the vm_prot enum, keeping it as it is. This approach would be extremely simple to implement but would not capture the semantics of the field very well. 
2. Parse the field using value instances:
	```
	vm_prot:
	  seq:
	    - id: val
	      type: u4
	  instances:
	    read:
	      value: ...
	    write:
	      value: ...
	...      
	```
	
	In this case, I think there could be two approaches to dealing with the values. 
	1. Capture the value: `(val & 0x01)` (for `VM_READ`)
	2. Capture whether or not the bit was set, treating it as a boolean: `(val & 0x01) == 0x01`
	
	What would be the best alternative? I've quickly tested all the aforementioned approaches by generating a MachO parser in Python. I've attached a (trivial) patch (mach_o.ksy.patch) which implements 2.2.
	
As I mentioned, I'm new to the project so I might have missed some features that could allow different implementations. Thank you for your work!


```
141,147d140
<   vm_prot:
<     0x00: none
<     0x01: read
<     0x02: write
<     0x04: execute
<     0x08: no_change
<     0x10: copy
194a188,202
>   vm_prot:
>     seq:
>       - id: val
>         type: u4
>     instances:
>       read:
>         value: (val & 0x01) == 0x01
>       write:
>         value: (val & 0x02) == 0x02
>       execute:
>         value: (val & 0x04) == 0x04
>       no_change:
>         value: (val & 0x08) == 0x08
>       copy:
>         value: (val & 0x10) == 0x10
257,258c265
<         type: u4
<         enum: vm_prot
---
>         type: vm_prot
260,261c267
<         type: u4
<         enum: vm_prot
---
>         type: vm_prot
```