stateful components should have easily manipulable internal state🔥
**Is your feature request related to a problem? Please describe.** 🤔
Component manipulation is limited. If components are objects, the meaning of the component tag should be to place any component into the document, no matter how it is produced or identified. One can declare a component that modifies its own state by referencing itself.

```
   component HelloWorld:
    y : int = 17

    `template`:
      tDiv:
        "Hello, world {self.y}!"
      tButton:
        "change world"
        @click:
          self.y += 1

```
However, one cannot even bind a component to an identifier and then add it to the document by the identifier. If we say
`  var hw = initHelloWorld("hw", y=88)`
then 
`hw` will fail to render anything, and 'component hw' will fail because the renderer currently assumes that we need to initialize a new component whenever we use the `component` tag.

**Describe the solution you'd like** 💡

1. `component hw` should render to the document in the same way ` component HelloWorld(y=88)` would. 
 ![image](https://github.com/HapticX/happyx/assets/126020181/b0301b3d-223e-4fb0-9dd6-a37b2296e67b)
 
2. In line with the goal of having methods and other things that modify component fields, any other changes required for the normal features of object declaration and field access to work should be implemented. I note, for example that one cannot declare [exported fields](https://nim-by-example.github.io/types/objects/) with `*`

**Describe alternatives you've considered** 💁‍♀️
Since text gets rendered just by placing the text node, it might be argued that the component tag should not exist at all and that the macro should just render any statement that results in a component in the same way. However I don't think its likely to be worth the change in the documented API

One can wrap components in some other datatype that houses the state which can be publicly modified, but this would be a needless addition of a new type that the programmer needs to juggle. stateful components are the only datatype that the programmer will really want to deal with.
