Connector re implementation

### Preliminary Work
#### Todo
- [x] Re factored code to use lower case directory names
- [x] Created draw directory and moved the drawing symbols inside it as a separate module ( needs to be imported explicitly for usage into ic class / oscilloscope class )
- [x] Moved `Gates/Connector.py` to a separate directory for connector elements.
- [x] made all threaded operations to auto start at time of `__init__()` execution. 

#### Changes
* Code is refactored to use lower case names / file names. [ gates.py is not refactored since it affects almost the entire codebase ]
* `Clock` instances, `Multivibrator` instances etc need not be separately started. They start upon initiation. [ We can avoid the extra line of `clock_instance.start()` ]

#### Code Samples

```
ha1 = HalfAdder(0, 1)
ha1.set_inputs(1,0) # Previously ha1.setInputs(1,0)
```
```
c = Clock(1, 500)
c.get_state()  # Previously c.start(); c.getState()
```

### Primary Work
#### Todo
- [x] linker module.
- [x] Bus support
- [x] Make `networkx` as a dependency to implement the digraphs
- [x] test for the linker module
- [x] Thread safety using Re-Entrant Locks.

#### Changes

Made provisions to help implement bus connectivity to all `combinational` and `sequential` modules ( esp. those deriving from basic gates and primitive structures ).

The connection state ( or voltage for analog ) is propagated to associated connections by means of the `AutoUpdater` daemon. This overcomes the limitations of `trigger()` in feed back circuits. AutoUpdater uses `networkx` to implement `DiGraphs` which stores the various links in a circuit.

The working can be summarized as below : 

Consider the future model of AND gate inputs / outputs based on Bus:
`AND.inputs` : ( Dynamically sized `bus` )
`AND.outputs` : ( Fixed size ( 1 bit ) `bus` )

Similarly assume inputs and output busses for `OR`

Now if a module MOD to be made takes 4 inputs and has 1 bit output ( A.B + C.D )

After initializing the Gates ...
```
# Inside initilization of and1
AutoUpdater.add_link( MOD.inputs[:2], and1.inputs[:2] )

# Inside initilization of and2
AutoUpdater.add_link( MOD.inputs[2:], and2.inputs[:2] )

# Inside initilization of or1
AutoUpdater.add_link( [and1.outputs, and2.outputs] , or1.inputs[:2] )

# in MOD
AutoUpdater.add_link( or1.outputs, MOD.outputs )
```
Now if `MOD.inputs[0].set_voltage(5)` is done to change one input.
It propagates to the output *without need for `triggering`*.

Advantages compared to triggering:

* If outputs are fed back to input of module, the updater keeps updating it as normally ( as if there were no feedback ) without getting stuck in an infinite loop ... 
* In triggering only next object in the sequential chain is visible... 
* The `AutoUpdater` perceives the whole circuit as a neatly organized structure of `DiGraph`.

Typical working algorithm for the `AutoUpdater` in w/ and w/o feedback :

for a node node1 ( a connector object ) : 
*Identifies connections from this node1 ( edges in the DiGraph ) -> 1 connected to 3, 1 connected to 2, 1 connected to 4
* Propagates values of 1 to 3, 2 and 4

for next node node2 : 
* Identify connection from 2 -> 2 connected to 1 <-- loop, a bug ( in most cases )
* Action taken: Updates values of 2 to 1

[ This wont affect the auto updater's performance either ... since it is going to indefinitely do this anyway for a given set of nodes in the digraph repeatedly  ... ]

In case of triggering -- 1 triggers 2 triggers 1 triggers 2 ... infinite recursive triggering ... the program hangs.

Feedback my be a bug or a desired design :

* If Feedback is a bug - output value keeps oscillating which can be debugged.
( 1 -> NOT -> 2 -> 1 ) a bug unstable op ... but executing does not halt the program.
* If Feedback is a desired one ( with appropriate stable block placed between 2 connectors ) the output is stable and correct.
( 1 -> NOT -> NOT -> 2 -> 1 ) stable ... Infinite triggering is avoided ...
 
#### Code Samples