implement schema-serde event streams

[lucix-aws]

implements schema-serde event stream support for aws-framed protocols (i.e. all of them)

https://smithy.io/2.0/aws/amazon-eventstream.html#amazon-eventstream

This is fundamentally the exact same thing that we had before, with all of the pieces of event stream wireup split out to allow for schema-serde. If you open up an existing generated event stream body, e.g. https://github.com/aws/aws-sdk-go-v2/blob/main/service/transcribestreaming/eventstream.go, you will see how things sort of map out in the new runtime. I made a point of preserving the structure of the old code as much as possible.

at a glance:

• ClientProtocol is extended with new event stream APIs. in practice since all the protocols use the same one, our implementations can just embed the new eventstream.Codec to get support
• the "generated" part of event streams is now just a type marshaler that figures out what variant schema to pass to the underlying event stream writer which is now in the runtime. pasted an example of that below
• as you saw in a previous PR i migrated the aws eventstream/ module over to smithy-go. in this patch i've also flattened it a bit by dropping the eventstreamapi/ sub-package, which had middleware stuff in it which caused an import cycle. that got moved over to transport/http and the constants got promoted up into smithy-go/eventstream/
• i ended up just adapting the SDK's sigv4 for event streams. I extended the auth resolution stuff to where smithyhttp.Signer can optionally implement a message signer, and the SDK provides support for that.

example of generated type adapter:

type audioStreamWriter struct {
    // smithyhttp.EventStreamWriter is new, previously basically its entire body of logic was generated inline per-op
    writer *smithyhttp.EventStreamWriter
}

var _ AudioStreamWriter = (*audioStreamWriter)(nil)

func (w *audioStreamWriter) Send(ctx context.Context, event types.AudioStream) error {
    var variant *smithy.Schema
    switch event.(type) {
    case *types.AudioStreamMemberAudioEvent:
        variant = schemas.AudioStream_AudioEvent
    case *types.AudioStreamMemberConfigurationEvent:
        variant = schemas.AudioStream_ConfigurationEvent
    default:
        return fmt.Errorf("unknown event type: %T", event)
    }   
    sv, ok := event.(smithy.Serializable)
    if !ok {
        return fmt.Errorf("event %T is not serializable", event)
    }   
   // pass it along to the new runtime, which handles delegating to the protocol
    return w.writer.Send(ctx, variant, sv) 
}

I did manual e2e tests w/ transcribestreaming,bedrockruntime, and cloudwatchlogs.

[lucix-aws]

relates #458

[Madrigal]

<3

[Madrigal]

TIL this pattern

[Madrigal]

mostly a question for me, but why inBindings mean look into event stream stuff?

[Madrigal]

should we do any bounds check?

[lucix-aws]

So instead of doing bounds check I made it actually type assert for Int8Value, Int16Value, etc. to match what the old code did. so they should be functionally equivalent now