Don't encode() non-unicode strings

Python2 has confusing unicode and string handling. Both str and unicode
are string types. The str type (which is what you get by default when
you use a string literal) is a raw byte type with no intrinsic encoding.
The unicode type is a list of code points. These two types have methods
to covert to each other. The unicode type has an `encode()` method to
convert the code points to a raw byte string using the given encoding.
The str type has a `decode()` method to convert the byte string to code
points using the given encoding.

When you write python code like `'foo'.encode('utf-8')` the python
interpreter sees you asking to invoke a unicode method on a str type so
it first converts the str of bytes to unicode code points via an
implicit `decode()` call using the system default encoding which is
almost always ascii. This set of code points is then converted back into
a string of bytes using the explicit encoding passed to the `encode()`
method.

At best, this conversion dance will be useless as ascii is a proper
subset of unicode. At worst, the byte string will contain non-ascii
characters (like 'å') and the implicit byte to unicode cast will fail
with an error like: <UnicodeDecodeError> 'ascii' codec can't decode byte
0xc3 in position 124: ordinal not in range(128)

We would only need to explicitly `encode()` a string if the string was
a unicode type string and we needed raw bytes rather than code points.
Since scap does not use unicode literals or `decode()` external byte
streams into code points, we can omit the use of `encode()` as our
strings are already literal byte streams rather than code points.

Bug: 68780
Change-Id: Iee9a36a8ca0cb78a91314801b2a4eaf59da0b16f