Add a way to express an indexable list of registers

[phausler]

It is often the case that interfacing with things like GPIO, spin locks, clocks etc have lists of registers that all share a given type.

Definitions often have a starting offset, stride between each indexable register, and a count of those registers.

This could be achieved without needing a macro to know what the type is by just allowing construction via an encapsulating type:

public struct RegisterList<Value> where Value: RegisterValue {
  let unsafeAddress: UInt
  let startOffset: UInt
  let stride: UInt
  let count: Int
  public init(unsafeAddress: UInt, startOffset: UInt, stride: UInt, count: Int) {
    self.unsafeAddress = unsafeAddress
    self.startOffset = startOffset
    self.stride = stride
    self.count = count
  }

  public subscript(index: Int) -> Register<Value> {
    precondition(index >= 0 && index < count)
    let addr = unsafeAddress + UInt(index) * stride + startOffset
    return Register(unsafeAddress: addr)
  }
}

[rauhul]

This is absolutely something we should support; at the register bank level I think this should be as simple as making the following code compile:

@RegisterArray(offset:stride:count:)
var gpio: RegisterArray<GPIO>

[rauhul]

WIP on register-array